@ecubelabs/atlassian-mcp 1.4.0-next.1 → 1.4.0-next.2

package/dist/confluence-tools/get-page-children.js

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+export const registerGetPageChildren = (server, confluenceService) => {
+    server.tool('get-page-children', 'Get direct child pages of a specific page', {
+        pageId: z.string().describe('ID of the parent page'),
+        cursor: z.string().optional().describe('Cursor for pagination'),
+        limit: z
+            .number()
+            .min(1)
+            .max(250)
+            .optional()
+            .describe('Maximum number of results to return (default: 25, max: 250)'),
+        sort: z
+            .enum([
+            'id',
+            '-id',
+            'created-date',
+            '-created-date',
+            'modified-date',
+            '-modified-date',
+            'title',
+            '-title',
+        ])
+            .optional()
+            .describe('Sort order for results'),
+    }, async ({ pageId, cursor, limit, sort }) => {
+        try {
+            const result = await confluenceService.getPageChildren(pageId, {
+                cursor,
+                limit,
+                sort,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to retrieve child pages: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+};

package/dist/confluence-tools/get-pages-for-label.js

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+export const registerGetPagesForLabel = (server, confluenceService) => {
+    server.tool('get-pages-for-label', 'Get pages associated with a specific label', {
+        labelId: z.string().describe('ID of the label to search for'),
+        bodyFormat: z
+            .array(z.enum(['storage', 'atlas_doc_format', 'view']))
+            .optional()
+            .describe('Format of the page body to retrieve'),
+        sort: z
+            .enum([
+            'id',
+            '-id',
+            'created-date',
+            '-created-date',
+            'modified-date',
+            '-modified-date',
+            'title',
+            '-title',
+        ])
+            .optional()
+            .describe('Sort order for results'),
+        cursor: z.string().optional().describe('Cursor for pagination'),
+        limit: z
+            .number()
+            .min(1)
+            .max(250)
+            .optional()
+            .describe('Maximum number of results to return (default: 25, max: 250)'),
+    }, async ({ labelId, bodyFormat, sort, cursor, limit }) => {
+        try {
+            const result = await confluenceService.getPagesByLabel(labelId, {
+                bodyFormat,
+                sort,
+                cursor,
+                limit,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to retrieve pages for label: ${JSON.stringify(error instanceof Error ? error.message : String(error))}`,
+                    },
+                ],
+            };
+        }
+    });
+};

package/dist/confluence-tools/get-pages.js

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+export const registerGetPages = (server, confluenceService) => {
+    server.tool('get-pages', 'Get list of pages from Confluence', {
+        id: z.array(z.string()).optional().describe('List of page IDs to retrieve'),
+        spaceId: z.array(z.string()).optional().describe('Filter pages by space IDs'),
+        title: z.string().optional().describe('Filter pages by title (partial match)'),
+        status: z
+            .array(z.enum(['current', 'trashed', 'historical', 'draft']))
+            .optional()
+            .describe('Filter pages by status'),
+        bodyFormat: z
+            .array(z.enum(['storage', 'atlas_doc_format', 'view']))
+            .optional()
+            .describe('Format of the page body to retrieve'),
+        cursor: z.string().optional().describe('Cursor for pagination'),
+        limit: z
+            .number()
+            .min(1)
+            .max(250)
+            .optional()
+            .describe('Maximum number of results to return (default: 25, max: 250)'),
+        sort: z
+            .enum([
+            'id',
+            '-id',
+            'created-date',
+            '-created-date',
+            'modified-date',
+            '-modified-date',
+            'title',
+            '-title',
+        ])
+            .optional()
+            .describe('Sort order for results'),
+    }, async ({ id, spaceId, title, status, bodyFormat, cursor, limit, sort }) => {
+        try {
+            const result = await confluenceService.getPages({
+                id,
+                spaceId,
+                title,
+                status,
+                bodyFormat,
+                cursor,
+                limit,
+                sort,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to retrieve pages: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+};

package/dist/confluence-tools/get-recently-created-pages.js

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+export const registerGetRecentlyCreatedPages = (server, confluenceService) => {
+    server.tool('get-recently-created-pages', 'Get recently created pages from Confluence (sorted by creation date)', {
+        spaceId: z.array(z.string()).optional().describe('Filter by space IDs'),
+        limit: z
+            .number()
+            .min(1)
+            .max(250)
+            .optional()
+            .describe('Maximum number of results to return (default: 25, max: 250)'),
+        bodyFormat: z
+            .array(z.enum(['storage', 'atlas_doc_format', 'view']))
+            .optional()
+            .describe('Format of the page body to retrieve'),
+    }, async ({ spaceId, limit, bodyFormat }) => {
+        try {
+            const result = await confluenceService.getRecentlyCreatedPages({
+                spaceId,
+                limit,
+                bodyFormat,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to retrieve recently created pages: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+};

package/dist/confluence-tools/get-recently-updated-pages.js

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+export const registerGetRecentlyUpdatedPages = (server, confluenceService) => {
+    server.tool('get-recently-updated-pages', 'Get recently updated pages from Confluence (sorted by modification date)', {
+        spaceId: z.array(z.string()).optional().describe('Filter by space IDs'),
+        limit: z
+            .number()
+            .min(1)
+            .max(250)
+            .optional()
+            .describe('Maximum number of results to return (default: 25, max: 250)'),
+        bodyFormat: z
+            .array(z.enum(['storage', 'atlas_doc_format', 'view']))
+            .optional()
+            .describe('Format of the page body to retrieve'),
+    }, async ({ spaceId, limit, bodyFormat }) => {
+        try {
+            const result = await confluenceService.getRecentlyUpdatedPages({
+                spaceId,
+                limit,
+                bodyFormat,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to retrieve recently updated pages: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+};

package/dist/confluence-tools/get-space-by-id.js

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+export const registerGetSpaceById = (server, confluenceService) => {
+    server.tool('get-space-by-id', 'Get a specific space by its ID', {
+        spaceId: z.string().describe('ID of the space to retrieve'),
+    }, async ({ spaceId }) => {
+        try {
+            const space = await confluenceService.getSpaceById(spaceId);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(space),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to retrieve space: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+};

package/dist/confluence-tools/get-spaces.js

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+export const registerGetSpaces = (server, confluenceService) => {
+    server.tool('get-spaces', 'Get list of spaces from Confluence', {
+        id: z.array(z.string()).optional().describe('Filter spaces by IDs'),
+        keys: z.array(z.string()).optional().describe('Filter spaces by keys'),
+        type: z
+            .array(z.enum(['global', 'personal']))
+            .optional()
+            .describe('Filter spaces by type'),
+        status: z
+            .array(z.enum(['current', 'archived']))
+            .optional()
+            .describe('Filter spaces by status'),
+        sort: z
+            .enum([
+            'id',
+            '-id',
+            'key',
+            '-key',
+            'name',
+            '-name',
+            'created-date',
+            '-created-date',
+            'modified-date',
+            '-modified-date',
+        ])
+            .optional()
+            .describe('Sort order for results'),
+        cursor: z.string().optional().describe('Cursor for pagination'),
+        limit: z
+            .number()
+            .min(1)
+            .max(250)
+            .optional()
+            .describe('Maximum number of results to return (default: 25, max: 250)'),
+    }, async ({ id, keys, type, status, sort, cursor, limit }) => {
+        try {
+            const result = await confluenceService.getSpaces({
+                id,
+                keys,
+                type,
+                status,
+                sort,
+                cursor,
+                limit,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to retrieve spaces: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+};

package/dist/confluence-tools/index.js

@@ -0,0 +1,22 @@
+// Read-only tools
+export { registerGetPages } from './get-pages.js';
+export { registerGetPagesForLabel } from './get-pages-for-label.js';
+export { registerGetPageById } from './get-page-by-id.js';
+export { registerGetLabels } from './get-labels.js';
+export { registerFindPagesByLabelName } from './find-pages-by-label-name.js';
+export { registerFindLabelByName } from './find-label-by-name.js';
+export { registerGetPageChildren } from './get-page-children.js';
+export { registerGetPageChildrenTree } from './get-page-children-tree.js';
+export { registerGetSpaces } from './get-spaces.js';
+export { registerGetSpaceById } from './get-space-by-id.js';
+export { registerFindSpaceByName } from './find-space-by-name.js';
+export { registerGetRecentlyUpdatedPages } from './get-recently-updated-pages.js';
+export { registerGetRecentlyCreatedPages } from './get-recently-created-pages.js';
+// Write tools
+export { registerCreatePage } from './create-page.js';
+export { registerUpdatePage } from './update-page.js';
+export { registerDeletePage } from './delete-page.js';
+export { registerAddLabelsToPage } from './add-labels-to-page.js';
+export { registerRemoveLabelFromPage } from './remove-label-from-page.js';
+// Help tool
+export { registerConfluenceStorageFormatHelp } from './confluence-storage-format-help.js';

package/dist/confluence-tools/remove-label-from-page.js

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+export const registerRemoveLabelFromPage = (server, confluenceService) => {
+    server.tool('remove-label-from-page', 'Remove a label from a Confluence page', {
+        pageId: z.string().describe('ID of the page to remove the label from'),
+        labelName: z.string().describe('Name of the label to remove'),
+    }, async ({ pageId, labelName }) => {
+        try {
+            await confluenceService.removeLabelFromPage(pageId, labelName);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Label "${labelName}" has been removed from page ${pageId}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to remove label from page: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+};

package/dist/confluence-tools/update-page.js

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+export const registerUpdatePage = (server, confluenceService) => {
+    server.tool('update-page', '⚠️ Update an existing Confluence page. 🚫 CRITICAL: NEVER use wiki markup ({info}, {code}), placeholder text ([Info Panel]), or plain text for Jira/dates/users. ✅ MANDATORY: MUST use confluence-storage-format-help tool BEFORE calling this. ONLY use storage format XML: <ac:structured-macro> for macros, <time> for dates, <ac:link> for users.', {
+        pageId: z.string().describe('ID of the page to update'),
+        title: z.string().describe('New title for the page'),
+        bodyRepresentation: z
+            .enum(['storage', 'atlas_doc_format', 'view'])
+            .default('storage')
+            .describe('Format of the page body content (default: storage)'),
+        bodyValue: z
+            .string()
+            .describe('🚫 NEVER use wiki markup ({info}, {code}) or placeholders ([Panel]). ✅ ONLY use storage format XML. MUST check confluence-storage-format-help tool first. Example: Panels use <ac:structured-macro ac:name="info"><ac:rich-text-body><p>text</p></ac:rich-text-body></ac:structured-macro>, Jira uses <ac:structured-macro ac:name="jira"><ac:parameter ac:name="key">KEY-123</ac:parameter></ac:structured-macro>, dates use <time datetime="YYYY-MM-DD"/>, users use <ac:link><ri:user ri:account-id="ID"/></ac:link>.'),
+        versionNumber: z.number().describe('Current version number of the page (must be incremented by 1)'),
+        versionMessage: z.string().optional().describe('Optional message describing the changes in this version'),
+        status: z
+            .enum(['current', 'draft'])
+            .optional()
+            .default('current')
+            .describe('Status of the page (default: current)'),
+    }, async ({ pageId, title, bodyRepresentation, bodyValue, versionNumber, versionMessage, status = 'current' }) => {
+        try {
+            const result = await confluenceService.updatePage(pageId, {
+                title,
+                body: {
+                    representation: bodyRepresentation,
+                    value: bodyValue,
+                },
+                version: {
+                    number: versionNumber,
+                    message: versionMessage,
+                },
+                status,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to update page: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+};