@jagadeesh52423/atlassian-mcp-server 1.0.2 → 1.1.0

package/dist/services/jira.js

@@ -1,4 +1,4 @@
-import { JiraClient } from '../jira-client.js';
+import { JiraClient } from '../clients/jira-client.js';
 export class JiraService {
     client;
     // Smart suggestion rules for common field patterns
@@ -30,33 +30,87 @@ export class JiraService {
         this.client = new JiraClient();
     }
     async searchIssues(options = {}) {
-        const { query, limit = 50, startAt = 0 } = options;
-        // Create bounded JQL query (Jira requires bounded queries now)
-        let jql = 'created >= -90d ORDER BY created DESC';
-        if (query) {
-            jql = `text ~ "${query}" AND created >= -90d ORDER BY created DESC`;
+        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: 'summary,description,status,assignee,created,updated'
+            fields: requestFields.join(',')
         };
         const response = await this.client.get('/rest/api/3/search/jql', params);
-        return response.issues.map((issue) => ({
-            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 || '',
-            created: issue.fields.created || '',
-            updated: issue.fields.updated || ''
-        }));
+        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', 'created', 'updated']
+            fields: ['summary', 'description', 'status', 'assignee', 'labels', 'created', 'updated']
         };
         const issue = await this.client.get(`/rest/api/3/issue/${issueKey}`, params);
         return {
@@ -66,6 +120,7 @@ export class JiraService {
             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 || ''
         };
@@ -472,6 +527,48 @@ export class JiraService {
     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}`, {
@@ -514,6 +611,242 @@ export class JiraService {
             }))
         })) || [];
     }
+    // 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 {
@@ -734,7 +1067,16 @@ export class JiraService {
         for (let i = 0; i < lines.length; i++) {
             const line = lines[i].trim();
             if (line === '') {
-                // Skip empty lines - let Claude handle spacing naturally
+                // 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.)
@@ -1023,6 +1365,11 @@ export class JiraService {
             { 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 => {
@@ -1038,6 +1385,21 @@ export class JiraService {
                 });
             }
         });
+        // 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
@@ -1085,11 +1447,20 @@ export class JiraService {
                 }
             }
             // Add formatted text
-            result.push({
-                type: 'text',
-                text: match.text,
-                marks: [{ type: match.type }]
-            });
+            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