@jagadeesh52423/atlassian-mcp-server 1.1.0 → 1.1.2

package/dist/services/jira.js

@@ -1,1486 +1,105 @@
 import { JiraClient } from '../clients/jira-client.js';
+import { JiraIssueService } from './jira/issues.js';
+import { JiraTransitionService } from './jira/transitions.js';
+import { JiraCommentService } from './jira/comments.js';
+import { JiraAttachmentService } from './jira/attachments.js';
+import { JiraLinkService } from './jira/links.js';
+import { JiraWorklogService } from './jira/worklogs.js';
+import { JiraWatcherService } from './jira/watchers.js';
+import { JiraLabelService } from './jira/labels.js';
+import { JiraSubtaskService } from './jira/subtasks.js';
+import { JiraAgileService } from './jira/agile.js';
+import { JiraVersionService } from './jira/versions.js';
+import { JiraMetadataService } from './jira/metadata.js';
 export class JiraService {
-    client;
-    // Smart suggestion rules for common field patterns
-    fieldSuggestionRules = [
-        {
-            pattern: /db.*script/i,
-            defaultValue: 'No',
-            contextRules: [
-                {
-                    condition: (issue) => /template|config|notification|mofu/i.test(issue.summary),
-                    value: 'No',
-                    reason: 'Template/config changes are typically done via MOFU tool and do not require database scripts'
-                }
-            ]
-        },
-        {
-            pattern: /test.*case|unit.*test/i,
-            defaultValue: 'Yes',
-            contextRules: [
-                {
-                    condition: (issue) => /template|notification|config/i.test(issue.summary),
-                    value: 'No',
-                    reason: 'Template and configuration changes may not require separate unit test cases'
-                }
-            ]
-        }
-    ];
+    issues;
+    transitions;
+    comments;
+    attachments;
+    links;
+    worklogs;
+    watchers;
+    labels;
+    subtasks;
+    agile;
+    versions;
+    metadata;
     constructor() {
-        this.client = new JiraClient();
-    }
-    async searchIssues(options = {}) {
-        const { query, assignee, status, project, labels, reporter, createdAfter, updatedAfter, jql: rawJql, fields: extraFields, limit = 50, startAt = 0 } = options;
-        let jql;
-        if (rawJql) {
-            // Use raw JQL directly when provided
-            jql = rawJql;
-        }
-        else {
-            // Build JQL from individual filters
-            const conditions = [];
-            if (query) {
-                conditions.push(`text ~ "${query}"`);
-            }
-            if (assignee) {
-                conditions.push(`assignee = ${assignee}`);
-            }
-            if (status) {
-                conditions.push(`status = "${status}"`);
-            }
-            if (project) {
-                conditions.push(`project = "${project}"`);
-            }
-            if (labels && labels.length > 0) {
-                conditions.push(labels.map(l => `labels = "${l}"`).join(' AND '));
-            }
-            if (reporter) {
-                conditions.push(`reporter = ${reporter}`);
-            }
-            if (createdAfter) {
-                // Support relative days (e.g., "10d") or absolute dates (e.g., "2026-01-15")
-                const dateValue = /^\d+d$/.test(createdAfter) ? `-${createdAfter}` : createdAfter;
-                conditions.push(`created >= "${dateValue}"`);
-            }
-            if (updatedAfter) {
-                const dateValue = /^\d+d$/.test(updatedAfter) ? `-${updatedAfter}` : updatedAfter;
-                conditions.push(`updated >= "${dateValue}"`);
-            }
-            // Only apply 90-day bound when no specific filters are provided
-            if (conditions.length === 0) {
-                conditions.push('created >= -90d');
-            }
-            jql = `${conditions.join(' AND ')} ORDER BY updated DESC`;
-        }
-        const defaultFields = ['summary', 'description', 'status', 'assignee', 'labels', 'created', 'updated'];
-        const requestFields = extraFields && extraFields.length > 0
-            ? [...new Set(extraFields)]
-            : defaultFields;
-        const params = {
-            jql,
-            maxResults: limit,
-            startAt,
-            fields: requestFields.join(',')
-        };
-        const response = await this.client.get('/rest/api/3/search/jql', params);
-        return response.issues.map((issue) => {
-            const result = {
-                key: issue.key,
-            };
-            for (const field of requestFields) {
-                const value = issue.fields[field];
-                if (value === undefined || value === null) {
-                    result[field] = null;
-                }
-                else if (field === 'description') {
-                    result[field] = this.extractTextFromADF(value);
-                }
-                else if (typeof value === 'object' && !Array.isArray(value)) {
-                    result[field] = value.name || value.displayName || value.value || value;
-                }
-                else if (Array.isArray(value)) {
-                    result[field] = value.map((v) => typeof v === 'object' ? (v.name || v.displayName || v.value || v) : v);
-                }
-                else {
-                    result[field] = value;
-                }
-            }
-            return result;
-        });
-    }
-    async getIssue(issueKey) {
-        const params = {
-            fields: ['summary', 'description', 'status', 'assignee', 'labels', 'created', 'updated']
-        };
-        const issue = await this.client.get(`/rest/api/3/issue/${issueKey}`, params);
-        return {
-            id: issue.id,
-            key: issue.key,
-            summary: issue.fields.summary || '',
-            description: this.extractTextFromADF(issue.fields.description),
-            status: issue.fields.status?.name || '',
-            assignee: issue.fields.assignee?.displayName || '',
-            labels: issue.fields.labels || [],
-            created: issue.fields.created || '',
-            updated: issue.fields.updated || ''
-        };
-    }
-    async createIssue(projectKey, summary, description, issueType = 'Task', additionalFields) {
-        const fields = {
-            project: { key: projectKey },
-            summary,
-            description: this.parseDescriptionToADF(description),
-            issuetype: { name: issueType }
-        };
-        // Add optional fields if provided
-        if (additionalFields) {
-            // Due date (format: YYYY-MM-DD)
-            if (additionalFields.duedate) {
-                fields.duedate = additionalFields.duedate;
-            }
-            // Priority (by name)
-            if (additionalFields.priority) {
-                fields.priority = { name: additionalFields.priority };
-            }
-            // Labels (array of strings)
-            if (additionalFields.labels && additionalFields.labels.length > 0) {
-                fields.labels = additionalFields.labels;
-            }
-            // Components (by name)
-            if (additionalFields.components && additionalFields.components.length > 0) {
-                fields.components = additionalFields.components.map(name => ({ name }));
-            }
-            // Assignee (by account ID)
-            if (additionalFields.assignee) {
-                fields.assignee = { accountId: additionalFields.assignee };
-            }
-            // Custom fields (merge directly into fields object)
-            if (additionalFields.customFields) {
-                Object.assign(fields, additionalFields.customFields);
-            }
-        }
-        const data = { fields };
-        const response = await this.client.post('/rest/api/3/issue', data);
-        return this.getIssue(response.key);
-    }
-    async updateIssue(issueKey, fields) {
-        const updateFields = {};
-        if (fields.summary) {
-            updateFields.summary = fields.summary;
-        }
-        if (fields.description) {
-            // Use proper ADF format for description updates
-            updateFields.description = this.parseDescriptionToADF(fields.description);
-        }
-        if (fields.assignee) {
-            updateFields.assignee = { accountId: fields.assignee };
-        }
-        const data = { fields: updateFields };
-        await this.client.put(`/rest/api/3/issue/${issueKey}`, data);
-        return this.getIssue(issueKey);
-    }
-    async transitionIssue(issueKey, transitionId, fieldValues) {
-        try {
-            const data = {
-                transition: { id: transitionId }
-            };
-            // Add field values if provided
-            if (fieldValues) {
-                data.fields = fieldValues;
-            }
-            await this.client.post(`/rest/api/3/issue/${issueKey}/transitions`, data);
-            return {
-                success: true,
-                message: `Issue ${issueKey} successfully transitioned`
-            };
-        }
-        catch (error) {
-            // Check if this is a required field error
-            if (error.response?.status === 400) {
-                const requiredFields = await this.handleTransitionError(issueKey, transitionId, error);
-                if (requiredFields.length > 0) {
-                    return {
-                        success: false,
-                        requiresInput: true,
-                        requiredFields,
-                        message: 'Transition requires additional fields. Please provide values for the required fields.',
-                        issueKey,
-                        transitionId
-                    };
-                }
-            }
-            // Re-throw if not a field validation error
-            throw error;
-        }
-    }
-    async getIssueTransitions(issueKey) {
-        const response = await this.client.get(`/rest/api/3/issue/${issueKey}/transitions`);
-        return response.transitions;
-    }
-    async addComment(issueKey, comment) {
-        const data = {
-            body: this.parseDescriptionToADF(comment)
-        };
-        await this.client.post(`/rest/api/3/issue/${issueKey}/comment`, data);
-    }
-    async getComments(issueKey) {
-        const response = await this.client.get(`/rest/api/3/issue/${issueKey}/comment`);
-        return response.comments.map((comment) => ({
-            id: comment.id,
-            author: comment.author?.displayName || 'Unknown',
-            authorAccountId: comment.author?.accountId,
-            body: this.extractTextFromADF(comment.body),
-            created: comment.created,
-            updated: comment.updated,
-            updateAuthor: comment.updateAuthor?.displayName
-        }));
-    }
-    async updateComment(issueKey, commentId, comment) {
-        const data = {
-            body: this.parseDescriptionToADF(comment)
-        };
-        const response = await this.client.put(`/rest/api/3/issue/${issueKey}/comment/${commentId}`, data);
-        return {
-            id: response.id,
-            author: response.author?.displayName || 'Unknown',
-            body: this.extractTextFromADF(response.body),
-            created: response.created,
-            updated: response.updated,
-            updateAuthor: response.updateAuthor?.displayName
-        };
-    }
-    async deleteComment(issueKey, commentId) {
-        await this.client.delete(`/rest/api/3/issue/${issueKey}/comment/${commentId}`);
-    }
-    extractTextFromADF(body) {
-        if (!body)
-            return '';
-        // If body is already a string (wiki markup), return it directly
-        if (typeof body === 'string') {
-            return this.formatWikiMarkup(body);
-        }
-        // If body doesn't have content property, it might be wiki markup in another format
-        if (!body.content) {
-            return this.formatWikiMarkup(String(body));
-        }
-        let text = '';
-        const extractFromContent = (content) => {
-            for (const item of content) {
-                if (item.type === 'text' && item.text) {
-                    text += item.text;
-                }
-                else if (item.type === 'hardBreak') {
-                    text += '\n';
-                }
-                else if (item.type === 'paragraph') {
-                    if (item.content) {
-                        extractFromContent(item.content);
-                    }
-                }
-                else if (item.type === 'heading') {
-                    const level = item.attrs?.level || 1;
-                    const prefix = '#'.repeat(level);
-                    text += `${prefix} `;
-                    if (item.content) {
-                        extractFromContent(item.content);
-                    }
-                }
-                else if (item.type === 'bulletList' || item.type === 'orderedList') {
-                    if (item.content) {
-                        extractFromContent(item.content);
-                    }
-                }
-                else if (item.type === 'listItem') {
-                    text += '- ';
-                    if (item.content) {
-                        extractFromContent(item.content);
-                    }
-                }
-                else if (item.type === 'codeBlock') {
-                    text += '```';
-                    if (item.content) {
-                        extractFromContent(item.content);
-                    }
-                    text += '```';
-                }
-                else if (item.type === 'table') {
-                    // Extract table as markdown
-                    if (item.content) {
-                        const rows = [];
-                        item.content.forEach((row) => {
-                            if (row.type === 'tableRow' && row.content) {
-                                const cells = [];
-                                row.content.forEach((cell) => {
-                                    if ((cell.type === 'tableCell' || cell.type === 'tableHeader') && cell.content) {
-                                        let cellText = '';
-                                        const extractCellText = (cellContent) => {
-                                            cellContent.forEach((cellItem) => {
-                                                if (cellItem.type === 'paragraph' && cellItem.content) {
-                                                    cellItem.content.forEach((textItem) => {
-                                                        if (textItem.type === 'text' && textItem.text) {
-                                                            cellText += textItem.text;
-                                                        }
-                                                    });
-                                                }
-                                            });
-                                        };
-                                        extractCellText(cell.content);
-                                        cells.push(cellText.trim());
-                                    }
-                                });
-                                if (cells.length > 0) {
-                                    rows.push(cells);
-                                }
-                            }
-                        });
-                        // Format as markdown table
-                        if (rows.length > 0) {
-                            const [headerRow, ...dataRows] = rows;
-                            // Header row
-                            text += '\n| ' + headerRow.join(' | ') + ' |\n';
-                            // Separator row
-                            text += '|' + headerRow.map(() => '--------').join('|') + '|\n';
-                            // Data rows
-                            dataRows.forEach(row => {
-                                text += '| ' + row.join(' | ') + ' |\n';
-                            });
-                        }
-                    }
-                }
-                else if (item.content) {
-                    extractFromContent(item.content);
-                }
-            }
-        };
-        extractFromContent(body.content);
-        return this.formatWikiMarkup(text.trim());
-    }
-    formatWikiMarkup(text) {
-        if (!text)
-            return '';
-        return text
-            // Convert Confluence headers to markdown headers
-            .replace(/^h([1-6])\.\s*/gm, (match, level) => '#'.repeat(parseInt(level)) + ' ')
-            // Convert horizontal rules
-            .replace(/^----+$/gm, '---')
-            // Handle panels - convert to blockquotes for better readability
-            .replace(/\{panel:title=([^|]*)[^}]*\}/g, '\n> **$1**\n>')
-            .replace(/\{panel\}/g, '\n')
-            // Handle colored text/backgrounds - keep the text but remove styling
-            .replace(/\{color:[^}]*\}([^{]*)\{color\}/g, '$1')
-            // Convert checkboxes
-            .replace(/☐/g, '- [ ]')
-            .replace(/☑/g, '- [x]')
-            // Clean up multiple newlines
-            .replace(/\n{3,}/g, '\n\n')
-            // Ensure proper spacing around headers
-            .replace(/\n(#{1,6}\s)/g, '\n\n$1')
-            .trim();
-    }
-    async getProjects() {
-        const response = await this.client.get('/rest/api/3/project');
-        return response;
-    }
-    async getIssueTypes(projectKey) {
-        const response = await this.client.get(`/rest/api/3/issue/createmeta/${projectKey}/issuetypes`);
-        return response.issueTypes;
-    }
-    async assignIssue(issueKey, accountId) {
-        const data = { accountId };
-        await this.client.put(`/rest/api/3/issue/${issueKey}/assignee`, data);
-    }
-    async getUsersByQuery(query) {
-        const params = {
-            query,
-            maxResults: 10
-        };
-        const response = await this.client.get('/rest/api/3/user/search', params);
-        return response;
-    }
-    // Attachment Methods
-    async getAttachments(issueKey) {
-        const issue = await this.client.get(`/rest/api/3/issue/${issueKey}`, {
-            fields: ['attachment']
-        });
-        return issue.fields.attachment?.map((att) => ({
-            id: att.id,
-            filename: att.filename,
-            author: att.author?.displayName || 'Unknown',
-            created: att.created,
-            size: att.size,
-            mimeType: att.mimeType,
-            content: att.content
-        })) || [];
-    }
-    async addAttachment(issueKey, filename, fileContent) {
-        // Note: fileContent should be base64 encoded
-        const FormData = (await import('form-data')).default;
-        const form = new FormData();
-        const buffer = Buffer.from(fileContent, 'base64');
-        form.append('file', buffer, { filename });
-        const response = await this.client.postFormData(`/rest/api/3/issue/${issueKey}/attachments`, form);
-        return response;
-    }
-    async deleteAttachment(attachmentId) {
-        await this.client.delete(`/rest/api/3/attachment/${attachmentId}`);
-    }
-    // Issue Linking Methods
-    async getIssueLinks(issueKey) {
-        const issue = await this.client.get(`/rest/api/3/issue/${issueKey}`, {
-            fields: ['issuelinks']
-        });
-        return issue.fields.issuelinks?.map((link) => ({
-            id: link.id,
-            type: link.type?.name || 'Unknown',
-            inward: link.inwardIssue ? {
-                key: link.inwardIssue.key,
-                summary: link.inwardIssue.fields?.summary,
-                status: link.inwardIssue.fields?.status?.name
-            } : null,
-            outward: link.outwardIssue ? {
-                key: link.outwardIssue.key,
-                summary: link.outwardIssue.fields?.summary,
-                status: link.outwardIssue.fields?.status?.name
-            } : null
-        })) || [];
-    }
-    async createIssueLink(inwardIssueKey, outwardIssueKey, linkType) {
-        const data = {
-            type: { name: linkType },
-            inwardIssue: { key: inwardIssueKey },
-            outwardIssue: { key: outwardIssueKey }
-        };
-        const response = await this.client.post('/rest/api/3/issueLink', data);
-        return response;
-    }
-    async deleteIssueLink(linkId) {
-        await this.client.delete(`/rest/api/3/issueLink/${linkId}`);
-    }
-    async getIssueLinkTypes() {
-        const response = await this.client.get('/rest/api/3/issueLinkType');
-        return response.issueLinkTypes.map((type) => ({
-            id: type.id,
-            name: type.name,
-            inward: type.inward,
-            outward: type.outward
-        }));
-    }
-    // Work Log Methods
-    async getWorkLogs(issueKey) {
-        const response = await this.client.get(`/rest/api/3/issue/${issueKey}/worklog`);
-        return response.worklogs?.map((worklog) => ({
-            id: worklog.id,
-            author: worklog.author?.displayName || 'Unknown',
-            authorAccountId: worklog.author?.accountId,
-            comment: this.extractTextFromADF(worklog.comment),
-            created: worklog.created,
-            updated: worklog.updated,
-            started: worklog.started,
-            timeSpent: worklog.timeSpent,
-            timeSpentSeconds: worklog.timeSpentSeconds
-        })) || [];
-    }
-    async addWorkLog(issueKey, timeSpentSeconds, comment, started) {
-        const data = {
-            timeSpentSeconds
-        };
-        if (started) {
-            data.started = started;
-        }
-        if (comment) {
-            data.comment = this.parseDescriptionToADF(comment);
-        }
-        const response = await this.client.post(`/rest/api/3/issue/${issueKey}/worklog`, data);
-        return response;
-    }
-    async updateWorkLog(issueKey, worklogId, timeSpentSeconds, comment) {
-        const data = {};
-        if (timeSpentSeconds !== undefined) {
-            data.timeSpentSeconds = timeSpentSeconds;
-        }
-        if (comment) {
-            data.comment = this.parseDescriptionToADF(comment);
-        }
-        const response = await this.client.put(`/rest/api/3/issue/${issueKey}/worklog/${worklogId}`, data);
-        return response;
-    }
-    async deleteWorkLog(issueKey, worklogId) {
-        await this.client.delete(`/rest/api/3/issue/${issueKey}/worklog/${worklogId}`);
-    }
-    // Watchers Methods
-    async getWatchers(issueKey) {
-        const response = await this.client.get(`/rest/api/3/issue/${issueKey}/watchers`);
-        return {
-            watchCount: response.watchCount,
-            isWatching: response.isWatching,
-            watchers: response.watchers?.map((watcher) => ({
-                accountId: watcher.accountId,
-                displayName: watcher.displayName,
-                emailAddress: watcher.emailAddress,
-                active: watcher.active
-            })) || []
-        };
-    }
-    async addWatcher(issueKey, accountId) {
-        await this.client.post(`/rest/api/3/issue/${issueKey}/watchers`, JSON.stringify(accountId));
-    }
-    async removeWatcher(issueKey, accountId) {
-        await this.client.delete(`/rest/api/3/issue/${issueKey}/watchers?accountId=${accountId}`);
-    }
-    // Field Discovery Methods
-    async getFields(type) {
-        const response = await this.client.get('/rest/api/3/field');
-        let fields = response.map((f) => ({
-            id: f.id,
-            name: f.name,
-            custom: f.custom || false,
-            schema: f.schema?.type || null,
-        }));
-        if (type === 'standard') {
-            fields = fields.filter((f) => !f.custom);
-        }
-        else if (type === 'custom') {
-            fields = fields.filter((f) => f.custom);
-        }
-        return fields.sort((a, b) => a.name.localeCompare(b.name));
-    }
-    // Label Methods
-    async getLabels(query, maxResults = 50) {
-        const params = { maxResults };
-        if (query) {
-            params.query = query;
-        }
-        const response = await this.client.get('/rest/api/3/label', params);
-        return response.values || [];
-    }
-    async addLabels(issueKey, labels) {
-        const data = {
-            update: {
-                labels: labels.map(label => ({ add: label }))
-            }
-        };
-        await this.client.put(`/rest/api/3/issue/${issueKey}`, data);
-    }
-    async removeLabels(issueKey, labels) {
-        const data = {
-            update: {
-                labels: labels.map(label => ({ remove: label }))
-            }
-        };
-        await this.client.put(`/rest/api/3/issue/${issueKey}`, data);
-    }
-    // Sub-task Methods
-    async getSubTasks(issueKey) {
-        const issue = await this.client.get(`/rest/api/3/issue/${issueKey}`, {
-            fields: ['subtasks']
-        });
-        return issue.fields.subtasks?.map((subtask) => ({
-            id: subtask.id,
-            key: subtask.key,
-            summary: subtask.fields?.summary,
-            status: subtask.fields?.status?.name,
-            assignee: subtask.fields?.assignee?.displayName
-        })) || [];
-    }
-    async createSubTask(parentKey, summary, description) {
-        const data = {
-            fields: {
-                project: { key: parentKey.split('-')[0] },
-                parent: { key: parentKey },
-                summary,
-                description: this.parseDescriptionToADF(description),
-                issuetype: { name: 'Sub-task' }
-            }
-        };
-        const response = await this.client.post('/rest/api/3/issue', data);
-        return this.getIssue(response.key);
-    }
-    // Issue History Methods
-    async getIssueHistory(issueKey) {
-        const response = await this.client.get(`/rest/api/3/issue/${issueKey}/changelog`);
-        return response.values?.map((change) => ({
-            id: change.id,
-            author: change.author?.displayName || 'Unknown',
-            authorAccountId: change.author?.accountId,
-            created: change.created,
-            items: change.items?.map((item) => ({
-                field: item.field,
-                fieldtype: item.fieldtype,
-                from: item.fromString,
-                to: item.toString
-            }))
-        })) || [];
-    }
-    // Agile Methods
-    async getAgileBoards(options) {
-        const params = { maxResults: 50 };
-        if (options?.name)
-            params.name = options.name;
-        if (options?.type)
-            params.type = options.type;
-        if (options?.projectKeyOrId)
-            params.projectKeyOrId = options.projectKeyOrId;
-        const response = await this.client.get('/rest/agile/1.0/board', params);
-        return response.values?.map((board) => ({
-            id: board.id,
-            name: board.name,
-            type: board.type,
-            location: board.location ? {
-                projectId: board.location.projectId,
-                projectKey: board.location.projectKey,
-                projectName: board.location.projectName,
-            } : null,
-        })) || [];
-    }
-    async getBoardIssues(boardId, options) {
-        const params = { maxResults: options?.maxResults || 50 };
-        if (options?.jql)
-            params.jql = options.jql;
-        if (options?.startAt)
-            params.startAt = options.startAt;
-        const response = await this.client.get(`/rest/agile/1.0/board/${boardId}/issue`, params);
-        return {
-            total: response.total,
-            issues: response.issues?.map((issue) => ({
-                key: issue.key,
-                summary: issue.fields?.summary || '',
-                status: issue.fields?.status?.name || '',
-                assignee: issue.fields?.assignee?.displayName || '',
-                priority: issue.fields?.priority?.name || '',
-            })) || [],
-        };
-    }
-    async getSprints(boardId, state) {
-        const params = { maxResults: 50 };
-        if (state)
-            params.state = state;
-        const response = await this.client.get(`/rest/agile/1.0/board/${boardId}/sprint`, params);
-        return response.values?.map((sprint) => ({
-            id: sprint.id,
-            name: sprint.name,
-            state: sprint.state,
-            startDate: sprint.startDate || null,
-            endDate: sprint.endDate || null,
-            completeDate: sprint.completeDate || null,
-            goal: sprint.goal || '',
-        })) || [];
-    }
-    async getSprintIssues(sprintId, options) {
-        const params = { maxResults: options?.maxResults || 50 };
-        if (options?.jql)
-            params.jql = options.jql;
-        if (options?.startAt)
-            params.startAt = options.startAt;
-        const response = await this.client.get(`/rest/agile/1.0/sprint/${sprintId}/issue`, params);
-        return {
-            total: response.total,
-            issues: response.issues?.map((issue) => ({
-                key: issue.key,
-                summary: issue.fields?.summary || '',
-                status: issue.fields?.status?.name || '',
-                assignee: issue.fields?.assignee?.displayName || '',
-                priority: issue.fields?.priority?.name || '',
-            })) || [],
-        };
-    }
-    // Batch Create
-    async batchCreateIssues(issues) {
-        if (issues.length > 50) {
-            throw new Error('Batch create supports a maximum of 50 issues at a time');
-        }
-        const issueUpdates = issues.map(issue => ({
-            fields: {
-                project: { key: issue.projectKey },
-                summary: issue.summary,
-                description: this.parseDescriptionToADF(issue.description),
-                issuetype: { name: issue.issueType || 'Task' },
-                ...issue.additionalFields,
-            },
-        }));
-        const response = await this.client.post('/rest/api/3/issue/bulk', { issueUpdates });
-        return {
-            issues: response.issues?.map((i) => ({ id: i.id, key: i.key, self: i.self })) || [],
-            errors: response.errors || [],
-        };
-    }
-    // Dev Status
-    async getDevStatus(issueId, applicationType, dataType) {
-        const params = { issueId };
-        if (applicationType)
-            params.applicationType = applicationType;
-        if (dataType)
-            params.dataType = dataType;
-        const response = await this.client.get('/rest/dev-status/latest/issue/detail', params);
-        return response;
-    }
-    // Delete Issue
-    async deleteIssue(issueKey, deleteSubtasks = false) {
-        const query = deleteSubtasks ? '?deleteSubtasks=true' : '';
-        await this.client.delete(`/rest/api/3/issue/${issueKey}${query}`);
-    }
-    // Sprint Management
-    async createSprint(boardId, name, options) {
-        const data = {
-            name,
-            originBoardId: boardId,
-        };
-        if (options?.startDate)
-            data.startDate = options.startDate;
-        if (options?.endDate)
-            data.endDate = options.endDate;
-        if (options?.goal)
-            data.goal = options.goal;
-        const response = await this.client.post('/rest/agile/1.0/sprint', data);
-        return {
-            id: response.id,
-            name: response.name,
-            state: response.state,
-            startDate: response.startDate || null,
-            endDate: response.endDate || null,
-            goal: response.goal || '',
-        };
-    }
-    async updateSprint(sprintId, updates) {
-        const data = {};
-        if (updates.name)
-            data.name = updates.name;
-        if (updates.state)
-            data.state = updates.state;
-        if (updates.startDate)
-            data.startDate = updates.startDate;
-        if (updates.endDate)
-            data.endDate = updates.endDate;
-        if (updates.goal !== undefined)
-            data.goal = updates.goal;
-        const response = await this.client.post(`/rest/agile/1.0/sprint/${sprintId}`, data);
-        return {
-            id: response.id,
-            name: response.name,
-            state: response.state,
-            startDate: response.startDate || null,
-            endDate: response.endDate || null,
-            goal: response.goal || '',
-        };
-    }
-    // Version/Release Management
-    async getProjectVersions(projectKey) {
-        const response = await this.client.get(`/rest/api/3/project/${projectKey}/versions`);
-        return response.map((v) => ({
-            id: v.id,
-            name: v.name,
-            description: v.description || '',
-            released: v.released || false,
-            archived: v.archived || false,
-            startDate: v.startDate || null,
-            releaseDate: v.releaseDate || null,
-        }));
-    }
-    async createVersion(projectKey, name, options) {
-        const data = {
-            project: projectKey,
-            name,
-        };
-        if (options?.description)
-            data.description = options.description;
-        if (options?.startDate)
-            data.startDate = options.startDate;
-        if (options?.releaseDate)
-            data.releaseDate = options.releaseDate;
-        if (options?.released !== undefined)
-            data.released = options.released;
-        const response = await this.client.post('/rest/api/3/version', data);
-        return {
-            id: response.id,
-            name: response.name,
-            description: response.description || '',
-            released: response.released || false,
-            archived: response.archived || false,
-            startDate: response.startDate || null,
-            releaseDate: response.releaseDate || null,
-        };
-    }
-    async updateVersion(versionId, updates) {
-        const data = {};
-        if (updates.name)
-            data.name = updates.name;
-        if (updates.description !== undefined)
-            data.description = updates.description;
-        if (updates.startDate)
-            data.startDate = updates.startDate;
-        if (updates.releaseDate)
-            data.releaseDate = updates.releaseDate;
-        if (updates.released !== undefined)
-            data.released = updates.released;
-        if (updates.archived !== undefined)
-            data.archived = updates.archived;
-        const response = await this.client.put(`/rest/api/3/version/${versionId}`, data);
-        return {
-            id: response.id,
-            name: response.name,
-            description: response.description || '',
-            released: response.released || false,
-            archived: response.archived || false,
-            startDate: response.startDate || null,
-            releaseDate: response.releaseDate || null,
-        };
-    }
-    // Epic Linking
-    async linkToEpic(issueKey, epicKey) {
-        // In next-gen projects, Epic is the parent. In classic, it's the Epic Link custom field.
-        // Try parent field first (works for next-gen/team-managed), fall back to Epic Link.
-        try {
-            await this.client.put(`/rest/api/3/issue/${issueKey}`, {
-                fields: { parent: { key: epicKey } }
-            });
-        }
-        catch {
-            // Fallback: find the Epic Link custom field ID and use that
-            const fields = await this.client.get('/rest/api/3/field');
-            const epicLinkField = fields.find((f) => f.name === 'Epic Link' || f.clauseNames?.includes('cf[10014]'));
-            if (epicLinkField) {
-                await this.client.put(`/rest/api/3/issue/${issueKey}`, {
-                    fields: { [epicLinkField.id]: epicKey }
-                });
-            }
-            else {
-                throw new Error('Could not find Epic Link field. Ensure the issue type supports epic linking.');
-            }
-        }
-    }
-    // Smart Field Handling Methods
-    async handleTransitionError(issueKey, transitionId, error) {
-        try {
-            // Get transition metadata with field information
-            const response = await this.client.get(`/rest/api/3/issue/${issueKey}/transitions?expand=transitions.fields`);
-            const transition = response.transitions.find((t) => t.id === transitionId);
-            if (!transition || !transition.fields) {
-                return [];
-            }
-            // Get issue details for context
-            const issue = await this.getIssue(issueKey);
-            // Analyze required fields and fields that may need values
-            const requiredFields = [];
-            for (const [fieldKey, fieldInfo] of Object.entries(transition.fields)) {
-                // Process all fields that have validation requirements or are commonly needed
-                const field = this.analyzeField(fieldKey, fieldInfo, issue);
-                requiredFields.push(field);
-            }
-            return requiredFields;
-        }
-        catch (err) {
-            console.error('Error analyzing transition fields:', err);
-            return [];
-        }
-    }
-    analyzeField(fieldKey, fieldInfo, issue) {
-        const field = {
-            key: fieldKey,
-            name: fieldInfo.name || fieldKey,
-            type: fieldInfo.schema?.type || 'unknown',
-            required: fieldInfo.required || false
-        };
-        // Extract options for select fields
-        if (fieldInfo.allowedValues) {
-            field.options = fieldInfo.allowedValues.map((val) => ({
-                id: val.id,
-                value: val.value
-            }));
-        }
-        // Generate smart suggestions
-        field.suggestion = this.generateFieldSuggestion(fieldInfo.name, field.options, issue);
-        return field;
-    }
-    generateFieldSuggestion(fieldName, options, issue) {
-        if (!fieldName)
-            return undefined;
-        // Apply suggestion rules
-        for (const rule of this.fieldSuggestionRules) {
-            if (rule.pattern.test(fieldName)) {
-                // Check context rules first
-                if (rule.contextRules && issue) {
-                    for (const contextRule of rule.contextRules) {
-                        if (contextRule.condition(issue)) {
-                            // Find matching option ID if available
-                            const matchingOption = options?.find(opt => opt.value === contextRule.value);
-                            return {
-                                value: contextRule.value,
-                                id: matchingOption?.id,
-                                reason: contextRule.reason
-                            };
-                        }
-                    }
-                }
-                // Fall back to default value
-                const matchingOption = options?.find(opt => opt.value === rule.defaultValue);
-                return {
-                    value: rule.defaultValue,
-                    id: matchingOption?.id,
-                    reason: `Default suggestion for ${fieldName.toLowerCase()}`
-                };
-            }
-        }
-        // Generic suggestions based on field name patterns
-        if (options && options.length > 0) {
-            if (/required|mandatory|needed/i.test(fieldName)) {
-                const yesOption = options.find(opt => /yes|true|required/i.test(opt.value));
-                if (yesOption) {
-                    return {
-                        value: yesOption.value,
-                        id: yesOption.id,
-                        reason: 'Field name suggests this is typically required'
-                    };
-                }
-            }
-            if (/optional|not.*required|skip/i.test(fieldName)) {
-                const noOption = options.find(opt => /no|false|not.*required|skip/i.test(opt.value));
-                if (noOption) {
-                    return {
-                        value: noOption.value,
-                        id: noOption.id,
-                        reason: 'Field name suggests this is typically not required'
-                    };
-                }
-            }
-        }
-        return undefined;
-    }
-    // Enhanced transition method with smart field handling
-    async transitionIssueInteractive(issueKey, transitionId, providedFields) {
-        // First attempt with provided fields
-        const result = await this.transitionIssue(issueKey, transitionId, providedFields);
-        if (result.success || !result.requiresInput) {
-            return result;
-        }
-        // If user provided fields but still failed, try to auto-fill based on suggestions
-        if (result.requiredFields && result.requiredFields.length > 0) {
-            const autoFields = { ...providedFields };
-            let hasAutoSuggestions = false;
-            for (const field of result.requiredFields) {
-                if (field.suggestion && !autoFields[field.key]) {
-                    if (field.suggestion.id) {
-                        autoFields[field.key] = { id: field.suggestion.id };
-                    }
-                    else {
-                        autoFields[field.key] = field.suggestion.value;
-                    }
-                    hasAutoSuggestions = true;
-                }
-            }
-            // Try transition again with auto-filled suggestions
-            if (hasAutoSuggestions) {
-                const retryResult = await this.transitionIssue(issueKey, transitionId, autoFields);
-                if (retryResult.success) {
-                    retryResult.message = `${retryResult.message} (auto-filled based on smart suggestions)`;
-                }
-                return retryResult;
-            }
-        }
-        return result;
-    }
-    // Convert description to wiki markup text format
-    parseDescriptionToWikiMarkup(description) {
-        const lines = description.split('\n');
-        const result = [];
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i].trim();
-            if (line === '') {
-                result.push('');
-                continue;
-            }
-            // Handle markdown headers
-            if (line.startsWith('###')) {
-                result.push('h3. ' + line.substring(3).trim());
-            }
-            else if (line.startsWith('##')) {
-                result.push('h2. ' + line.substring(2).trim());
-            }
-            else if (line.startsWith('#')) {
-                result.push('h1. ' + line.substring(1).trim());
-            }
-            // Handle markdown tables
-            else if (line.includes('|') && line.trim() !== '|') {
-                const cells = line.split('|').map(cell => cell.trim()).filter(cell => cell !== '');
-                if (cells.length >= 2) {
-                    // Collect table rows
-                    const allTableRows = [];
-                    let currentLine = i;
-                    while (currentLine < lines.length) {
-                        const tableLine = lines[currentLine].trim();
-                        if (tableLine === '') {
-                            currentLine++;
-                            continue;
-                        }
-                        if (!tableLine.includes('|')) {
-                            break;
-                        }
-                        // Skip separator lines
-                        if (tableLine.match(/^\|?[\s\-:|]+\|?$/)) {
-                            currentLine++;
-                            continue;
-                        }
-                        const rowCells = tableLine.split('|').map(cell => cell.trim()).filter(cell => cell !== '');
-                        if (rowCells.length >= 2) {
-                            allTableRows.push(rowCells);
-                        }
-                        else {
-                            break;
-                        }
-                        currentLine++;
-                    }
-                    // Convert to Confluence wiki markup
-                    if (allTableRows.length > 0) {
-                        // Header row
-                        if (allTableRows.length > 0) {
-                            result.push('||*' + allTableRows[0].join('*||*') + '*||');
-                            // Add separator line based on number of columns
-                            const numColumns = allTableRows[0].length;
-                            const separator = '|' + '-|'.repeat(numColumns);
-                            result.push(separator);
-                        }
-                        // Data rows
-                        for (let rowIdx = 1; rowIdx < allTableRows.length; rowIdx++) {
-                            result.push('|' + allTableRows[rowIdx].join('|') + '|');
-                        }
-                        // Skip processed lines
-                        i = currentLine - 1;
-                        continue;
-                    }
-                }
-                // If not a valid table, treat as regular text
-                result.push(line);
-            }
-            // Handle bullet points
-            else if (line.startsWith('- ') || line.startsWith('* ')) {
-                result.push('* ' + line.substring(2).trim());
-            }
-            // Regular text
-            else {
-                result.push(line);
-            }
-        }
-        return result.join('\n');
-    }
-    // Enhanced description parser that converts text to proper ADF format
-    parseDescriptionToADF(description) {
-        const lines = description.split('\n');
-        const content = [];
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i].trim();
-            if (line === '') {
-                // Only add an empty paragraph for double blank lines (true paragraph breaks)
-                // Single blank lines are natural separators between block elements and don't need extra spacing
-                const nextLine = i + 1 < lines.length ? lines[i + 1].trim() : '';
-                if (nextLine === '') {
-                    const lastNode = content[content.length - 1];
-                    const isLastEmpty = lastNode && lastNode.type === 'paragraph' && (!lastNode.content || lastNode.content.length === 0);
-                    if (!isLastEmpty) {
-                        content.push({ type: 'paragraph', content: [] });
-                    }
-                }
-                continue;
-            }
-            // Handle Confluence wiki markup headers (h1., h2., h3., etc.)
-            const confluenceHeaderMatch = line.match(/^h([1-6])\.\s*(.*)$/);
-            if (confluenceHeaderMatch) {
-                const level = parseInt(confluenceHeaderMatch[1]);
-                const headerText = confluenceHeaderMatch[2];
-                content.push({
-                    type: 'heading',
-                    attrs: { level },
-                    content: [{
-                            type: 'text',
-                            text: headerText
-                        }]
-                });
-                continue;
-            }
-            // Handle markdown headers (## Header, ### Header)
-            if (line.startsWith('###')) {
-                content.push({
-                    type: 'heading',
-                    attrs: { level: 3 },
-                    content: [{
-                            type: 'text',
-                            text: line.substring(3).trim()
-                        }]
-                });
-            }
-            else if (line.startsWith('##')) {
-                content.push({
-                    type: 'heading',
-                    attrs: { level: 2 },
-                    content: [{
-                            type: 'text',
-                            text: line.substring(2).trim()
-                        }]
-                });
-            }
-            else if (line.startsWith('#')) {
-                content.push({
-                    type: 'heading',
-                    attrs: { level: 1 },
-                    content: [{
-                            type: 'text',
-                            text: line.substring(1).trim()
-                        }]
-                });
-            }
-            // Handle horizontal rules (---- or ----)
-            else if (/^-{4,}$/.test(line)) {
-                content.push({
-                    type: 'rule'
-                });
-            }
-            // Handle Confluence panels
-            else if (line.match(/^\{panel:/)) {
-                const panelMatch = line.match(/^\{panel:title=([^|]*)[^}]*\}$/);
-                if (panelMatch) {
-                    const title = panelMatch[1];
-                    // Start collecting panel content
-                    const panelContent = [];
-                    i++; // Move to next line
-                    // Collect content until we hit {panel}
-                    while (i < lines.length && !lines[i].trim().match(/^\{panel\}$/)) {
-                        const panelLine = lines[i].trim();
-                        if (panelLine) {
-                            panelContent.push({
-                                type: 'paragraph',
-                                content: this.parseInlineFormatting(panelLine)
-                            });
-                        }
-                        i++;
-                    }
-                    // Create panel as an info panel (closest ADF equivalent)
-                    content.push({
-                        type: 'panel',
-                        attrs: { panelType: 'info' },
-                        content: [
-                            {
-                                type: 'paragraph',
-                                content: [{
-                                        type: 'text',
-                                        text: title,
-                                        marks: [{ type: 'strong' }]
-                                    }]
-                            },
-                            ...panelContent
-                        ]
-                    });
-                }
-            }
-            // Handle bullet points
-            else if (line.startsWith('- ') || line.startsWith('* ')) {
-                // Check if we need to start a new bullet list or continue existing one
-                const lastItem = content[content.length - 1];
-                const bulletText = line.substring(2).trim();
-                if (lastItem && lastItem.type === 'bulletList') {
-                    lastItem.content.push({
-                        type: 'listItem',
-                        content: [{
-                                type: 'paragraph',
-                                content: this.parseInlineFormatting(bulletText)
-                            }]
-                    });
-                }
-                else {
-                    content.push({
-                        type: 'bulletList',
-                        content: [{
-                                type: 'listItem',
-                                content: [{
-                                        type: 'paragraph',
-                                        content: this.parseInlineFormatting(bulletText)
-                                    }]
-                            }]
-                    });
-                }
-            }
-            // Handle numbered lists
-            else if (/^\d+\.\s/.test(line)) {
-                const match = line.match(/^\d+\.\s(.+)$/);
-                if (match) {
-                    const listText = match[1];
-                    const lastItem = content[content.length - 1];
-                    if (lastItem && lastItem.type === 'orderedList') {
-                        lastItem.content.push({
-                            type: 'listItem',
-                            content: [{
-                                    type: 'paragraph',
-                                    content: this.parseInlineFormatting(listText)
-                                }]
-                        });
-                    }
-                    else {
-                        content.push({
-                            type: 'orderedList',
-                            content: [{
-                                    type: 'listItem',
-                                    content: [{
-                                            type: 'paragraph',
-                                            content: this.parseInlineFormatting(listText)
-                                        }]
-                                }]
-                        });
-                    }
-                }
-            }
-            // Handle code blocks (```)
-            else if (line.startsWith('```')) {
-                const codeLines = [];
-                i++; // Skip the opening ```
-                while (i < lines.length && !lines[i].trim().startsWith('```')) {
-                    codeLines.push(lines[i]);
-                    i++;
-                }
-                content.push({
-                    type: 'codeBlock',
-                    content: [{
-                            type: 'text',
-                            text: codeLines.join('\n')
-                        }]
-                });
-            }
-            // Handle markdown tables - convert to proper ADF table structure
-            else if (line.includes('|') && line.trim() !== '|') {
-                const cells = line.split('|').map(cell => cell.trim()).filter(cell => cell !== '');
-                if (cells.length >= 2) {
-                    // Collect all table rows from current position
-                    const allTableRows = [];
-                    // Start from current line and collect consecutive table rows
-                    let tableEndIndex = i;
-                    for (let tableIdx = i; tableIdx < lines.length; tableIdx++) {
-                        const tableLine = lines[tableIdx].trim();
-                        // Skip empty lines
-                        if (tableLine === '') {
-                            tableEndIndex = tableIdx;
-                            continue;
-                        }
-                        // Stop if no pipes (end of table)
-                        if (!tableLine.includes('|')) {
-                            tableEndIndex = tableIdx - 1;
-                            break;
-                        }
-                        // Skip separator lines like |-|-|
-                        if (tableLine.match(/^\|?[\s\-:|]+\|?$/)) {
-                            tableEndIndex = tableIdx;
-                            continue;
-                        }
-                        // Parse row cells
-                        const rowCells = tableLine.split('|').map(cell => cell.trim()).filter(cell => cell !== '');
-                        if (rowCells.length >= 2) {
-                            allTableRows.push(rowCells);
-                            tableEndIndex = tableIdx;
-                        }
-                        else {
-                            tableEndIndex = tableIdx - 1;
-                            break; // End of table
-                        }
-                    }
-                    // Convert to proper ADF table structure if we have table rows
-                    if (allTableRows.length > 0) {
-                        // Create proper ADF table structure
-                        const tableRows = [];
-                        // Header row (first row)
-                        if (allTableRows.length > 0) {
-                            const headerCells = allTableRows[0].map(cellText => ({
-                                type: 'tableHeader',
-                                attrs: {},
-                                content: [{
-                                        type: 'paragraph',
-                                        content: this.parseInlineFormatting(cellText)
-                                    }]
-                            }));
-                            tableRows.push({
-                                type: 'tableRow',
-                                content: headerCells
-                            });
-                        }
-                        // Data rows (remaining rows)
-                        for (let rowIdx = 1; rowIdx < allTableRows.length; rowIdx++) {
-                            const dataCells = allTableRows[rowIdx].map(cellText => ({
-                                type: 'tableCell',
-                                attrs: {},
-                                content: [{
-                                        type: 'paragraph',
-                                        content: this.parseInlineFormatting(cellText)
-                                    }]
-                            }));
-                            tableRows.push({
-                                type: 'tableRow',
-                                content: dataCells
-                            });
-                        }
-                        // Create the complete table structure
-                        content.push({
-                            type: 'table',
-                            attrs: {
-                                isNumberColumnEnabled: false,
-                                layout: 'default'
-                            },
-                            content: tableRows
-                        });
-                        // Skip the lines we've processed
-                        i = tableEndIndex; // Skip the table rows we just processed
-                        continue;
-                    }
-                }
-                // If we reach here, it's not a valid table, treat as regular paragraph
-                content.push({
-                    type: 'paragraph',
-                    content: this.parseInlineFormatting(line)
-                });
-            }
-            // Regular paragraph
-            else {
-                content.push({
-                    type: 'paragraph',
-                    content: this.parseInlineFormatting(line)
-                });
-            }
-        }
-        // If no content was parsed, add a simple paragraph
-        if (content.length === 0) {
-            content.push({
-                type: 'paragraph',
-                content: [{
-                        type: 'text',
-                        text: description || ''
-                    }]
-            });
-        }
-        return {
-            type: 'doc',
-            version: 1,
-            content
-        };
-    }
-    // Parse inline formatting like **bold**, *italic*, `code`, {{code}}, emojis
-    parseInlineFormatting(text) {
-        const result = [];
-        let currentPos = 0;
-        // Process patterns in order of precedence to avoid conflicts
-        // **bold** should be processed before *italic* to handle **text** correctly
-        const patterns = [
-            { regex: /\*\*(.*?)\*\*/g, type: 'strong' }, // **bold** (process first)
-            { regex: /`([^`]+?)`/g, type: 'code' }, // `code` (markdown style)
-            { regex: /\{\{(.+?)\}\}/g, type: 'code' }, // {{code}} (Confluence/Jira wiki style)
-        ];
-        // Link patterns (markdown [text](url) and Jira wiki [text|url])
-        const linkPatterns = [
-            { regex: /\[([^\]]+?)\]\(([^)]+?)\)/g }, // [text](url) - markdown style
-            { regex: /\[([^|\]]+?)\|([^\]]+?)\]/g }, // [text|url] - Jira wiki style
-        ];
-        let matches = [];
-        // Find all formatting matches
-        patterns.forEach(pattern => {
-            let match;
-            const regex = new RegExp(pattern.regex.source, 'g');
-            while ((match = regex.exec(text)) !== null) {
-                matches.push({
-                    start: match.index,
-                    end: match.index + match[0].length,
-                    text: match[1],
-                    type: pattern.type,
-                    fullMatch: match[0]
-                });
-            }
-        });
-        // Find all link matches
-        linkPatterns.forEach(pattern => {
-            let match;
-            const regex = new RegExp(pattern.regex.source, 'g');
-            while ((match = regex.exec(text)) !== null) {
-                matches.push({
-                    start: match.index,
-                    end: match.index + match[0].length,
-                    text: match[1],
-                    type: 'link',
-                    href: match[2],
-                    fullMatch: match[0]
-                });
-            }
-        });
-        // Sort matches by position and remove overlapping matches
-        matches.sort((a, b) => a.start - b.start);
-        // After processing bold and code, handle italic patterns that don't overlap
-        let tempText = text;
-        // Remove already matched bold and code patterns from consideration
-        matches.forEach(match => {
-            tempText = tempText.substring(0, match.start) + ' '.repeat(match.end - match.start) + tempText.substring(match.end);
-        });
-        // Now find italic patterns in the remaining text
-        const italicRegex = /\*([^*]+?)\*/g;
-        let italicMatch;
-        while ((italicMatch = italicRegex.exec(tempText)) !== null) {
-            matches.push({
-                start: italicMatch.index,
-                end: italicMatch.index + italicMatch[0].length,
-                text: italicMatch[1],
-                type: 'em',
-                fullMatch: italicMatch[0]
-            });
-        }
-        // Sort matches by position and remove overlapping matches
-        matches.sort((a, b) => a.start - b.start);
-        // Filter out overlapping matches (keep the first one in case of conflict)
-        const filteredMatches = [];
-        for (const match of matches) {
-            const isOverlapping = filteredMatches.some(existing => (match.start >= existing.start && match.start < existing.end) ||
-                (match.end > existing.start && match.end <= existing.end) ||
-                (match.start <= existing.start && match.end >= existing.end));
-            if (!isOverlapping) {
-                filteredMatches.push(match);
-            }
-        }
-        // Sort filtered matches by position for proper processing
-        filteredMatches.sort((a, b) => a.start - b.start);
-        // Process text with formatting
-        filteredMatches.forEach(match => {
-            // Add text before the match
-            if (match.start > currentPos) {
-                const beforeText = text.substring(currentPos, match.start);
-                if (beforeText) {
-                    result.push({
-                        type: 'text',
-                        text: beforeText
-                    });
-                }
-            }
-            // Add formatted text
-            if (match.type === 'link') {
-                result.push({
-                    type: 'text',
-                    text: match.text,
-                    marks: [{ type: 'link', attrs: { href: match.href } }]
-                });
-            }
-            else {
-                result.push({
-                    type: 'text',
-                    text: match.text,
-                    marks: [{ type: match.type }]
-                });
-            }
-            currentPos = match.end;
-        });
-        // Add remaining text
-        if (currentPos < text.length) {
-            const remainingText = text.substring(currentPos);
-            if (remainingText) {
-                result.push({
-                    type: 'text',
-                    text: remainingText
-                });
-            }
-        }
-        // If no formatting was found, return simple text
-        if (result.length === 0) {
-            result.push({
-                type: 'text',
-                text: text
-            });
-        }
-        return result;
-    }
+        const client = new JiraClient();
+        this.issues = new JiraIssueService(client);
+        this.comments = new JiraCommentService(client);
+        this.attachments = new JiraAttachmentService(client);
+        this.links = new JiraLinkService(client);
+        this.worklogs = new JiraWorklogService(client);
+        this.watchers = new JiraWatcherService(client);
+        this.labels = new JiraLabelService(client);
+        this.subtasks = new JiraSubtaskService(client, this.issues);
+        this.agile = new JiraAgileService(client);
+        this.versions = new JiraVersionService(client);
+        this.metadata = new JiraMetadataService(client);
+        this.transitions = new JiraTransitionService(client, this.issues);
+    }
+    // Issues
+    searchIssues(opts) { return this.issues.searchIssues(opts); }
+    getIssue(key, fields) { return this.issues.getIssue(key, fields); }
+    createIssue(...args) { return this.issues.createIssue(...args); }
+    updateIssue(...args) { return this.issues.updateIssue(...args); }
+    deleteIssue(key, deleteSubtasks) { return this.issues.deleteIssue(key, deleteSubtasks); }
+    assignIssue(key, accountId) { return this.issues.assignIssue(key, accountId); }
+    batchCreateIssues(...args) { return this.issues.batchCreateIssues(...args); }
+    getIssueHistory(key) { return this.issues.getIssueHistory(key); }
+    getDevStatus(id, appType, dataType) { return this.issues.getDevStatus(id, appType, dataType); }
+    // Transitions
+    getIssueTransitions(key) { return this.transitions.getIssueTransitions(key); }
+    transitionIssue(key, transitionId, fields) { return this.transitions.transitionIssue(key, transitionId, fields); }
+    transitionIssueInteractive(key, transitionId, fields) { return this.transitions.transitionIssueInteractive(key, transitionId, fields); }
+    // Comments
+    addComment(key, comment) { return this.comments.addComment(key, comment); }
+    getComments(key) { return this.comments.getComments(key); }
+    updateComment(key, commentId, comment) { return this.comments.updateComment(key, commentId, comment); }
+    deleteComment(key, commentId) { return this.comments.deleteComment(key, commentId); }
+    // Attachments
+    getAttachments(key) { return this.attachments.getAttachments(key); }
+    addAttachment(key, filename, content) { return this.attachments.addAttachment(key, filename, content); }
+    deleteAttachment(attachmentId) { return this.attachments.deleteAttachment(attachmentId); }
+    // Links
+    getIssueLinks(key) { return this.links.getIssueLinks(key); }
+    createIssueLink(inward, outward, type) { return this.links.createIssueLink(inward, outward, type); }
+    deleteIssueLink(linkId) { return this.links.deleteIssueLink(linkId); }
+    getIssueLinkTypes() { return this.links.getIssueLinkTypes(); }
+    linkToEpic(key, epicKey) { return this.links.linkToEpic(key, epicKey); }
+    // Worklogs
+    getWorkLogs(key) { return this.worklogs.getWorkLogs(key); }
+    addWorkLog(key, seconds, comment, started) { return this.worklogs.addWorkLog(key, seconds, comment, started); }
+    updateWorkLog(key, worklogId, seconds, comment) { return this.worklogs.updateWorkLog(key, worklogId, seconds, comment); }
+    deleteWorkLog(key, worklogId) { return this.worklogs.deleteWorkLog(key, worklogId); }
+    // Watchers
+    getWatchers(key) { return this.watchers.getWatchers(key); }
+    addWatcher(key, accountId) { return this.watchers.addWatcher(key, accountId); }
+    removeWatcher(key, accountId) { return this.watchers.removeWatcher(key, accountId); }
+    // Labels
+    getLabels(query, maxResults) { return this.labels.getLabels(query, maxResults); }
+    addLabels(key, labels) { return this.labels.addLabels(key, labels); }
+    removeLabels(key, labels) { return this.labels.removeLabels(key, labels); }
+    // Subtasks
+    getSubTasks(key) { return this.subtasks.getSubTasks(key); }
+    createSubTask(parentKey, summary, description) { return this.subtasks.createSubTask(parentKey, summary, description); }
+    // Agile
+    getAgileBoards(opts) { return this.agile.getAgileBoards(opts); }
+    getBoardIssues(boardId, opts) { return this.agile.getBoardIssues(boardId, opts); }
+    getSprints(boardId, state) { return this.agile.getSprints(boardId, state); }
+    getSprintIssues(sprintId, opts) { return this.agile.getSprintIssues(sprintId, opts); }
+    moveIssuesToSprint(sprintId, issueKeys) { return this.agile.moveIssuesToSprint(sprintId, issueKeys); }
+    createSprint(boardId, name, opts) { return this.agile.createSprint(boardId, name, opts); }
+    updateSprint(sprintId, updates) { return this.agile.updateSprint(sprintId, updates); }
+    // Versions
+    getProjectVersions(projectKey) { return this.versions.getProjectVersions(projectKey); }
+    createVersion(projectKey, name, opts) { return this.versions.createVersion(projectKey, name, opts); }
+    updateVersion(versionId, updates) { return this.versions.updateVersion(versionId, updates); }
+    // Metadata
+    getProjects() { return this.metadata.getProjects(); }
+    getIssueTypes(projectKey) { return this.metadata.getIssueTypes(projectKey); }
+    getFields(type, query) { return this.metadata.getFields(type, query); }
+    getUsersByQuery(query) { return this.metadata.getUsersByQuery(query); }
 }
 //# sourceMappingURL=jira.js.map