@ecubelabs/atlassian-mcp 1.4.0-next.7 → 1.5.0

package/dist/libs/confluence-storage-format-utils.js

@@ -0,0 +1,468 @@
+/**
+ * Confluence Storage Format Utilities
+ *
+ * This module provides helper functions to create Confluence storage format (XHTML-based) content
+ * without manually writing XML. It supports common elements like headings, text formatting, lists,
+ * tables, macros, images, and links.
+ *
+ * @see https://confluence.atlassian.com/doc/confluence-storage-format-790796544.html
+ */
+/**
+ * Confluence Storage Format Builder
+ * Provides a fluent API for building Confluence storage format content
+ */
+export class ConfluenceStorageFormatBuilder {
+    content = [];
+    /**
+     * Add a heading
+     * @param level Heading level (1-6)
+     * @param text Heading text
+     */
+    heading(level, text) {
+        this.content.push(`<h${level}>${this.escapeHtml(text)}</h${level}>`);
+        return this;
+    }
+    /**
+     * Add a paragraph
+     */
+    paragraph(text) {
+        this.content.push(`<p>${this.escapeHtml(text)}</p>`);
+        return this;
+    }
+    /**
+     * Add bold text
+     */
+    bold(text) {
+        return `<strong>${this.escapeHtml(text)}</strong>`;
+    }
+    /**
+     * Add italic text
+     */
+    italic(text) {
+        return `<em>${this.escapeHtml(text)}</em>`;
+    }
+    /**
+     * Add underlined text
+     */
+    underline(text) {
+        return `<u>${this.escapeHtml(text)}</u>`;
+    }
+    /**
+     * Add strikethrough text
+     */
+    strikethrough(text) {
+        return `<s>${this.escapeHtml(text)}</s>`;
+    }
+    /**
+     * Add a line break
+     */
+    lineBreak() {
+        this.content.push('<br />');
+        return this;
+    }
+    /**
+     * Add a horizontal rule
+     */
+    horizontalRule() {
+        this.content.push('<hr />');
+        return this;
+    }
+    /**
+     * Add an unordered list
+     */
+    unorderedList(items) {
+        const listItems = items.map((item) => `<li>${this.escapeHtml(item)}</li>`).join('');
+        this.content.push(`<ul>${listItems}</ul>`);
+        return this;
+    }
+    /**
+     * Add an ordered list
+     */
+    orderedList(items) {
+        const listItems = items.map((item) => `<li>${this.escapeHtml(item)}</li>`).join('');
+        this.content.push(`<ol>${listItems}</ol>`);
+        return this;
+    }
+    /**
+     * Add a blockquote
+     */
+    blockquote(text) {
+        this.content.push(`<blockquote><p>${this.escapeHtml(text)}</p></blockquote>`);
+        return this;
+    }
+    /**
+     * Add preformatted text
+     */
+    preformatted(text) {
+        this.content.push(`<pre>${this.escapeHtml(text)}</pre>`);
+        return this;
+    }
+    /**
+     * Add a table
+     */
+    table(rows) {
+        const tableRows = rows
+            .map((row) => {
+            const cells = row.cells
+                .map((cell) => {
+                const tag = cell.isHeader ? 'th' : 'td';
+                const attrs = [];
+                if (cell.rowspan && cell.rowspan > 1) {
+                    attrs.push(`rowspan="${cell.rowspan}"`);
+                }
+                if (cell.colspan && cell.colspan > 1) {
+                    attrs.push(`colspan="${cell.colspan}"`);
+                }
+                const attrStr = attrs.length > 0 ? ' ' + attrs.join(' ') : '';
+                return `<${tag}${attrStr}>${this.escapeHtml(cell.content)}</${tag}>`;
+            })
+                .join('');
+            return `<tr>${cells}</tr>`;
+        })
+            .join('');
+        this.content.push(`<table><tbody>${tableRows}</tbody></table>`);
+        return this;
+    }
+    /**
+     * Add a code block macro
+     * @param code Code content
+     * @param language Programming language for syntax highlighting (e.g., 'java', 'python', 'javascript')
+     * @param options Additional options
+     */
+    codeBlock(code, language, options) {
+        const params = [];
+        if (language) {
+            params.push({ name: 'language', value: language });
+        }
+        if (options?.title) {
+            params.push({ name: 'title', value: options.title });
+        }
+        if (options?.linenumbers) {
+            params.push({ name: 'linenumbers', value: 'true' });
+        }
+        if (options?.collapse) {
+            params.push({ name: 'collapse', value: 'true' });
+        }
+        if (options?.firstline) {
+            params.push({ name: 'firstline', value: String(options.firstline) });
+        }
+        this.content.push(this.createMacro('code', params, code, true));
+        return this;
+    }
+    /**
+     * Add an info panel macro
+     */
+    infoPanel(content, title, showIcon = true) {
+        const params = [];
+        if (title) {
+            params.push({ name: 'title', value: title });
+        }
+        params.push({ name: 'icon', value: showIcon ? 'true' : 'false' });
+        this.content.push(this.createMacro('info', params, content));
+        return this;
+    }
+    /**
+     * Add a note panel macro
+     */
+    notePanel(content, title, showIcon = true) {
+        const params = [];
+        if (title) {
+            params.push({ name: 'title', value: title });
+        }
+        params.push({ name: 'icon', value: showIcon ? 'true' : 'false' });
+        this.content.push(this.createMacro('note', params, content));
+        return this;
+    }
+    /**
+     * Add a warning panel macro
+     */
+    warningPanel(content, title, showIcon = true) {
+        const params = [];
+        if (title) {
+            params.push({ name: 'title', value: title });
+        }
+        params.push({ name: 'icon', value: showIcon ? 'true' : 'false' });
+        this.content.push(this.createMacro('warning', params, content));
+        return this;
+    }
+    /**
+     * Add a tip panel macro
+     */
+    tipPanel(content, title, showIcon = true) {
+        const params = [];
+        if (title) {
+            params.push({ name: 'title', value: title });
+        }
+        params.push({ name: 'icon', value: showIcon ? 'true' : 'false' });
+        this.content.push(this.createMacro('tip', params, content));
+        return this;
+    }
+    /**
+     * Add a custom panel macro
+     */
+    panel(content, options) {
+        const params = [];
+        if (options?.title) {
+            params.push({ name: 'title', value: options.title });
+        }
+        if (options?.borderStyle) {
+            params.push({ name: 'borderStyle', value: options.borderStyle });
+        }
+        if (options?.borderColor) {
+            params.push({ name: 'borderColor', value: options.borderColor });
+        }
+        if (options?.borderWidth) {
+            params.push({ name: 'borderWidth', value: String(options.borderWidth) });
+        }
+        if (options?.bgColor) {
+            params.push({ name: 'bgColor', value: options.bgColor });
+        }
+        if (options?.titleBGColor) {
+            params.push({ name: 'titleBGColor', value: options.titleBGColor });
+        }
+        if (options?.titleColor) {
+            params.push({ name: 'titleColor', value: options.titleColor });
+        }
+        this.content.push(this.createMacro('panel', params, content));
+        return this;
+    }
+    /**
+     * Add a link to a Confluence page
+     */
+    pageLink(options) {
+        const linkBody = options.linkText
+            ? `<ac:plain-text-link-body><![CDATA[${options.linkText}]]></ac:plain-text-link-body>`
+            : '';
+        const link = `<ac:link><ri:page ri:content-title="${this.escapeAttr(options.pageTitle)}" ri:space-key="${this.escapeAttr(options.spaceKey)}" />${linkBody}</ac:link>`;
+        this.content.push(link);
+        return this;
+    }
+    /**
+     * Add an external link
+     */
+    externalLink(url, linkText) {
+        const linkBody = linkText ? `<ac:plain-text-link-body><![CDATA[${linkText}]]></ac:plain-text-link-body>` : '';
+        const link = `<ac:link><ri:url ri:value="${this.escapeAttr(url)}" />${linkBody}</ac:link>`;
+        this.content.push(link);
+        return this;
+    }
+    /**
+     * Add a link to an attachment
+     */
+    attachmentLink(filename, linkText) {
+        const linkBody = linkText ? `<ac:plain-text-link-body><![CDATA[${linkText}]]></ac:plain-text-link-body>` : '';
+        const link = `<ac:link><ri:attachment ri:filename="${this.escapeAttr(filename)}" />${linkBody}</ac:link>`;
+        this.content.push(link);
+        return this;
+    }
+    /**
+     * Add an image from attachment
+     */
+    imageFromAttachment(filename, options) {
+        const attrs = [];
+        if (options?.width) {
+            attrs.push(`ac:width="${options.width}"`);
+        }
+        if (options?.height) {
+            attrs.push(`ac:height="${options.height}"`);
+        }
+        const attrStr = attrs.length > 0 ? ' ' + attrs.join(' ') : '';
+        const image = `<ac:image${attrStr}><ri:attachment ri:filename="${this.escapeAttr(filename)}" /></ac:image>`;
+        this.content.push(image);
+        return this;
+    }
+    /**
+     * Add an image from URL
+     */
+    imageFromUrl(url, options) {
+        const attrs = [];
+        if (options?.width) {
+            attrs.push(`ac:width="${options.width}"`);
+        }
+        if (options?.height) {
+            attrs.push(`ac:height="${options.height}"`);
+        }
+        const attrStr = attrs.length > 0 ? ' ' + attrs.join(' ') : '';
+        const image = `<ac:image${attrStr}><ri:url ri:value="${this.escapeAttr(url)}" /></ac:image>`;
+        this.content.push(image);
+        return this;
+    }
+    /**
+     * Add a task list
+     */
+    taskList(tasks) {
+        const taskItems = tasks
+            .map((task) => {
+            const status = task.completed ? 'complete' : 'incomplete';
+            return `<ac:task><ac:task-status>${status}</ac:task-status><ac:task-body>${this.escapeHtml(task.text)}</ac:task-body></ac:task>`;
+        })
+            .join('');
+        this.content.push(`<ac:task-list>${taskItems}</ac:task-list>`);
+        return this;
+    }
+    /**
+     * Add a table of contents macro
+     */
+    tableOfContents(options) {
+        const params = [];
+        if (options?.maxLevel) {
+            params.push({ name: 'maxLevel', value: String(options.maxLevel) });
+        }
+        if (options?.minLevel) {
+            params.push({ name: 'minLevel', value: String(options.minLevel) });
+        }
+        if (options?.exclude) {
+            params.push({ name: 'exclude', value: options.exclude });
+        }
+        if (options?.type) {
+            params.push({ name: 'type', value: options.type });
+        }
+        if (options?.outline !== undefined) {
+            params.push({ name: 'outline', value: String(options.outline) });
+        }
+        if (options?.style) {
+            params.push({ name: 'style', value: options.style });
+        }
+        this.content.push(this.createMacro('toc', params));
+        return this;
+    }
+    /**
+     * Add a layout with sections and cells
+     */
+    layout(sections) {
+        const sectionElements = sections
+            .map((section) => {
+            const cells = section.cells
+                .map((cellContent) => `<ac:layout-cell>${cellContent}</ac:layout-cell>`)
+                .join('');
+            return `<ac:layout-section ac:type="${this.escapeAttr(section.type)}">${cells}</ac:layout-section>`;
+        })
+            .join('');
+        this.content.push(`<ac:layout>${sectionElements}</ac:layout>`);
+        return this;
+    }
+    /**
+     * Add raw storage format content
+     */
+    raw(storageFormat) {
+        this.content.push(storageFormat);
+        return this;
+    }
+    /**
+     * Build the final storage format string
+     */
+    build() {
+        return this.content.join('\n');
+    }
+    /**
+     * Create a structured macro
+     */
+    createMacro(name, parameters, body, isPlainTextBody = false) {
+        const params = parameters
+            .map((p) => `<ac:parameter ac:name="${this.escapeAttr(p.name)}">${this.escapeHtml(p.value)}</ac:parameter>`)
+            .join('');
+        let bodyContent = '';
+        if (body) {
+            if (isPlainTextBody) {
+                bodyContent = `<ac:plain-text-body><![CDATA[${body}]]></ac:plain-text-body>`;
+            }
+            else {
+                bodyContent = `<ac:rich-text-body>${this.escapeHtml(body)}</ac:rich-text-body>`;
+            }
+        }
+        return `<ac:structured-macro ac:name="${this.escapeAttr(name)}">${params}${bodyContent}</ac:structured-macro>`;
+    }
+    /**
+     * Escape HTML special characters
+     */
+    escapeHtml(text) {
+        return text
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&#039;');
+    }
+    /**
+     * Escape XML attribute values
+     */
+    escapeAttr(text) {
+        return text
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&apos;');
+    }
+}
+/**
+ * Static helper functions for common Confluence storage format patterns
+ */
+export class ConfluenceStorageFormat {
+    /**
+     * Create a new builder instance
+     */
+    static builder() {
+        return new ConfluenceStorageFormatBuilder();
+    }
+    /**
+     * Create a heading
+     */
+    static heading(level, text) {
+        return new ConfluenceStorageFormatBuilder().heading(level, text).build();
+    }
+    /**
+     * Create a paragraph
+     */
+    static paragraph(text) {
+        return new ConfluenceStorageFormatBuilder().paragraph(text).build();
+    }
+    /**
+     * Create a code block
+     */
+    static codeBlock(code, language, options) {
+        return new ConfluenceStorageFormatBuilder().codeBlock(code, language, options).build();
+    }
+    /**
+     * Create an info panel
+     */
+    static infoPanel(content, title) {
+        return new ConfluenceStorageFormatBuilder().infoPanel(content, title).build();
+    }
+    /**
+     * Create a note panel
+     */
+    static notePanel(content, title) {
+        return new ConfluenceStorageFormatBuilder().notePanel(content, title).build();
+    }
+    /**
+     * Create a warning panel
+     */
+    static warningPanel(content, title) {
+        return new ConfluenceStorageFormatBuilder().warningPanel(content, title).build();
+    }
+    /**
+     * Create a tip panel
+     */
+    static tipPanel(content, title) {
+        return new ConfluenceStorageFormatBuilder().tipPanel(content, title).build();
+    }
+    /**
+     * Create a table
+     */
+    static table(rows) {
+        return new ConfluenceStorageFormatBuilder().table(rows).build();
+    }
+    /**
+     * Create an unordered list
+     */
+    static unorderedList(items) {
+        return new ConfluenceStorageFormatBuilder().unorderedList(items).build();
+    }
+    /**
+     * Create an ordered list
+     */
+    static orderedList(items) {
+        return new ConfluenceStorageFormatBuilder().orderedList(items).build();
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ecubelabs/atlassian-mcp",
-  "version": "1.4.0-next.7",
+  "version": "1.5.0",
   "bin": "./dist/index.js",
   "repository": {
     "url": "https://github.com/Ecube-Labs/skynet.git"
@@ -37,6 +37,5 @@
     "semantic-release-yarn": "^3.0.2",
     "ts-node": "^10.9.2",
     "typescript": "^5.8.2"
-  },
-  "stableVersion": "1.0.0"
+  }
 }