@neverprepared/mcp-markdown-to-confluence 1.0.1 → 1.1.1

package/dist/index.js

@@ -5,15 +5,43 @@ import { z } from 'zod';
 import { ConfluenceClient } from 'confluence.js';
 import matter from 'gray-matter';
 import { readFile } from 'fs/promises';
-import { parseMarkdownToADF, renderADFDoc, executeADFProcessingPipeline, createPublisherFunctions, } from '@markdown-confluence/lib';
-import { MermaidRendererPlugin } from '@markdown-confluence/lib';
-import { PuppeteerMermaidRenderer } from '@markdown-confluence/mermaid-puppeteer-renderer';
+import { parseMarkdownToADF, renderADFDoc, executeADFProcessingPipeline, createPublisherFunctions, MermaidRendererPlugin, } from '@markdown-confluence/lib';
+import { KrokiClient, KrokiMermaidRenderer, KrokiDiagramPlugin } from './kroki/index.js';
 // ---------------------------------------------------------------------------
 // Environment
 // ---------------------------------------------------------------------------
 const CONFLUENCE_BASE_URL = process.env.CONFLUENCE_BASE_URL ?? '';
 const CONFLUENCE_USERNAME = process.env.CONFLUENCE_USERNAME ?? '';
 const CONFLUENCE_API_TOKEN = process.env.CONFLUENCE_API_TOKEN ?? '';
+const KROKI_URL = process.env.KROKI_URL ?? 'http://localhost:8371';
+// ---------------------------------------------------------------------------
+// Kroki client
+// ---------------------------------------------------------------------------
+const krokiClient = new KrokiClient(KROKI_URL);
+// Diagram types and their preferred output format
+// PNG is preferred when supported; SVG is the universal fallback
+const KROKI_DIAGRAM_CONFIGS = [
+    { type: 'plantuml', format: 'png' },
+    { type: 'graphviz', format: 'png' },
+    { type: 'dot', format: 'png' },
+    { type: 'ditaa', format: 'svg' },
+    { type: 'nomnoml', format: 'svg' },
+    { type: 'd2', format: 'svg' },
+    { type: 'dbml', format: 'svg' },
+    { type: 'erd', format: 'svg' },
+    { type: 'svgbob', format: 'svg' },
+    { type: 'pikchr', format: 'svg' },
+    { type: 'bytefield', format: 'svg' },
+    { type: 'wavedrom', format: 'svg' },
+    { type: 'vega', format: 'svg' },
+    { type: 'vega-lite', format: 'svg' },
+    { type: 'bpmn', format: 'svg' },
+    { type: 'c4plantuml', format: 'png' },
+];
+const SUPPORTED_DIAGRAM_TYPES = [
+    'mermaid',
+    ...KROKI_DIAGRAM_CONFIGS.map((c) => c.type),
+];
 // ---------------------------------------------------------------------------
 // Confluence client
 // ---------------------------------------------------------------------------
@@ -39,7 +67,7 @@ const stubAdaptor = {
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
-function countMermaidBlocks(adf) {
+function countDiagramBlocks(adf) {
     if (typeof adf !== 'object' || adf === null)
         return 0;
     const node = adf;
@@ -47,17 +75,17 @@ function countMermaidBlocks(adf) {
     if (node['type'] === 'codeBlock' &&
         typeof node['attrs'] === 'object' &&
         node['attrs'] !== null &&
-        node['attrs']['language'] === 'mermaid') {
+        SUPPORTED_DIAGRAM_TYPES.includes(node['attrs']['language'])) {
         count += 1;
     }
     for (const value of Object.values(node)) {
         if (Array.isArray(value)) {
             for (const item of value) {
-                count += countMermaidBlocks(item);
+                count += countDiagramBlocks(item);
             }
         }
         else if (typeof value === 'object' && value !== null) {
-            count += countMermaidBlocks(value);
+            count += countDiagramBlocks(value);
         }
     }
     return count;
@@ -68,10 +96,10 @@ function countMermaidBlocks(adf) {
 async function publishMarkdown(markdown, title, spaceKey, pageId, parentId, skipPreview = false) {
     // Parse markdown → ADF
     const adf = parseMarkdownToADF(markdown, CONFLUENCE_BASE_URL);
-    const mermaidCount = countMermaidBlocks(adf);
+    const diagramCount = countDiagramBlocks(adf);
     if (!skipPreview) {
         const previewText = renderADFDoc(adf);
-        return { isPreview: true, previewText, mermaidCount };
+        return { isPreview: true, previewText, diagramCount };
     }
     // ----- Full publish -----
     let currentVersion = 1;
@@ -128,8 +156,11 @@ async function publishMarkdown(markdown, title, spaceKey, pageId, parentId, skip
     }
     // Build publisher functions
     const publisherFunctions = createPublisherFunctions(confluenceClient, stubAdaptor, resolvedPageId, title, currentAttachments);
-    // Run ADF processing pipeline (renders mermaid diagrams)
-    const finalAdf = await executeADFProcessingPipeline([new MermaidRendererPlugin(new PuppeteerMermaidRenderer())], adf, publisherFunctions);
+    // Run ADF processing pipeline (renders diagrams via Kroki)
+    const finalAdf = await executeADFProcessingPipeline([
+        new MermaidRendererPlugin(new KrokiMermaidRenderer(krokiClient)),
+        ...KROKI_DIAGRAM_CONFIGS.map((c) => new KrokiDiagramPlugin(c.type, krokiClient, c.format)),
+    ], adf, publisherFunctions);
     // Update the page with the final ADF
     const updateParams = {
         id: resolvedPageId,
@@ -152,7 +183,7 @@ async function publishMarkdown(markdown, title, spaceKey, pageId, parentId, skip
         isPreview: false,
         pageId: resolvedPageId,
         version: currentVersion + 1,
-        mermaidCount,
+        diagramCount,
         url,
     };
 }
@@ -228,11 +259,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 .object({ markdown: z.string(), title: z.string() })
                 .parse(args);
             const adf = parseMarkdownToADF(input.markdown, CONFLUENCE_BASE_URL);
-            const mermaidCount = countMermaidBlocks(adf);
+            const diagramCount = countDiagramBlocks(adf);
             const previewText = renderADFDoc(adf);
             const lines = [previewText];
-            if (mermaidCount > 0) {
-                lines.push(`\n[Note: ${mermaidCount} mermaid diagram(s) detected — they will be rendered as images when published.]`);
+            if (diagramCount > 0) {
+                lines.push(`\n[Note: ${diagramCount} diagram(s) detected — they will be rendered as images when published.]`);
             }
             return { content: [{ type: 'text', text: lines.join('') }] };
         }
@@ -250,8 +281,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const result = await publishMarkdown(input.markdown, input.title, input.spaceKey, input.pageId, input.parentId, input.skip_preview);
             if (result.isPreview) {
                 const lines = ['=== PREVIEW ===\n', result.previewText ?? ''];
-                if ((result.mermaidCount ?? 0) > 0) {
-                    lines.push(`\n[Note: ${result.mermaidCount} mermaid diagram(s) detected — they will be rendered when published.]`);
+                if ((result.diagramCount ?? 0) > 0) {
+                    lines.push(`\n[Note: ${result.diagramCount} diagram(s) detected — they will be rendered when published.]`);
                 }
                 lines.push('\n\nCall again with skip_preview: true to publish to Confluence.');
                 return { content: [{ type: 'text', text: lines.join('') }] };
@@ -265,7 +296,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                             `Title: ${input.title}`,
                             `Page ID: ${result.pageId}`,
                             `Version: ${result.version}`,
-                            `Mermaid diagrams rendered: ${result.mermaidCount}`,
+                            `Diagrams rendered: ${result.diagramCount}`,
                             `URL: ${result.url}`,
                         ].join('\n'),
                     },
@@ -315,8 +346,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     '=== PREVIEW ===\n',
                     result.previewText ?? '',
                 ];
-                if ((result.mermaidCount ?? 0) > 0) {
-                    lines.push(`\n[Note: ${result.mermaidCount} mermaid diagram(s) detected — they will be rendered when published.]`);
+                if ((result.diagramCount ?? 0) > 0) {
+                    lines.push(`\n[Note: ${result.diagramCount} diagram(s) detected — they will be rendered when published.]`);
                 }
                 lines.push('\n\nCall again with skip_preview: true to publish to Confluence.');
                 return { content: [{ type: 'text', text: lines.join('') }] };
@@ -330,7 +361,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                             `File: ${input.filePath}`,
                             `Page ID: ${result.pageId}`,
                             `Version: ${result.version}`,
-                            `Mermaid diagrams rendered: ${result.mermaidCount}`,
+                            `Diagrams rendered: ${result.diagramCount}`,
                             `URL: ${result.url}`,
                         ].join('\n'),
                     },

package/dist/kroki/KrokiClient.d.ts

@@ -0,0 +1,5 @@
+export declare class KrokiClient {
+    private baseUrl;
+    constructor(baseUrl?: string);
+    renderDiagram(diagramType: string, source: string, outputFormat?: string): Promise<Buffer>;
+}

package/dist/kroki/KrokiClient.js

@@ -0,0 +1,19 @@
+export class KrokiClient {
+    baseUrl;
+    constructor(baseUrl = 'http://localhost:8371') {
+        this.baseUrl = baseUrl.replace(/\/+$/, '');
+    }
+    async renderDiagram(diagramType, source, outputFormat = 'png') {
+        const url = `${this.baseUrl}/${diagramType}/${outputFormat}`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'text/plain' },
+            body: source,
+        });
+        if (!response.ok) {
+            const body = await response.text();
+            throw new Error(`Kroki render failed for ${diagramType} (${response.status}): ${body}`);
+        }
+        return Buffer.from(await response.arrayBuffer());
+    }
+}

package/dist/kroki/KrokiDiagramPlugin.d.ts

@@ -0,0 +1,23 @@
+import type { JSONDocNode } from '@atlaskit/editor-json-transformer';
+import type { ADFProcessingPlugin, PublisherFunctions } from '@markdown-confluence/lib';
+import type { KrokiClient } from './KrokiClient.js';
+interface ChartData {
+    name: string;
+    data: string;
+}
+interface UploadedImage {
+    id: string;
+    collection: string;
+    width: number;
+    height: number;
+}
+export declare class KrokiDiagramPlugin implements ADFProcessingPlugin<ChartData[], Record<string, UploadedImage | null>> {
+    private diagramType;
+    private client;
+    private outputFormat;
+    constructor(diagramType: string, client: KrokiClient, outputFormat?: string);
+    extract(adf: JSONDocNode): ChartData[];
+    transform(charts: ChartData[], supportFunctions: PublisherFunctions): Promise<Record<string, UploadedImage | null>>;
+    load(adf: JSONDocNode, imageMap: Record<string, UploadedImage | null>): JSONDocNode;
+}
+export {};

package/dist/kroki/KrokiDiagramPlugin.js

@@ -0,0 +1,87 @@
+import { filter, traverse } from '@atlaskit/adf-utils/traverse';
+import SparkMD5 from 'spark-md5';
+function getDiagramFileName(diagramType, content, outputFormat) {
+    const text = content ?? `${diagramType} placeholder`;
+    const hash = SparkMD5.hash(text);
+    const ext = outputFormat === 'png' ? 'png' : 'svg';
+    const uploadFilename = `RenderedKrokiChart-${diagramType}-${hash}.${ext}`;
+    return { uploadFilename, text };
+}
+export class KrokiDiagramPlugin {
+    diagramType;
+    client;
+    outputFormat;
+    constructor(diagramType, client, outputFormat = 'svg') {
+        this.diagramType = diagramType;
+        this.client = client;
+        this.outputFormat = outputFormat;
+    }
+    extract(adf) {
+        const nodes = filter(adf, (node) => node.type === 'codeBlock' &&
+            (node.attrs || {})?.['language'] === this.diagramType);
+        const charts = new Set(nodes.map((node) => {
+            const details = getDiagramFileName(this.diagramType, node?.content?.at(0)?.text, this.outputFormat);
+            return {
+                name: details.uploadFilename,
+                data: details.text,
+            };
+        }));
+        return Array.from(charts);
+    }
+    async transform(charts, supportFunctions) {
+        let imageMap = {};
+        if (charts.length === 0) {
+            return imageMap;
+        }
+        const rendered = await Promise.all(charts.map(async (chart) => {
+            const buffer = await this.client.renderDiagram(this.diagramType, chart.data, this.outputFormat);
+            return [chart.name, buffer];
+        }));
+        for (const [name, buffer] of rendered) {
+            const uploaded = await supportFunctions.uploadBuffer(name, buffer);
+            imageMap = { ...imageMap, [name]: uploaded };
+        }
+        return imageMap;
+    }
+    load(adf, imageMap) {
+        let afterAdf = adf;
+        afterAdf =
+            traverse(afterAdf, {
+                codeBlock: (node, _parent) => {
+                    if (node?.attrs?.['language'] === this.diagramType) {
+                        const content = node?.content?.at(0)?.text;
+                        if (!content) {
+                            return;
+                        }
+                        const filename = getDiagramFileName(this.diagramType, content, this.outputFormat);
+                        if (!imageMap[filename.uploadFilename]) {
+                            return;
+                        }
+                        const mappedImage = imageMap[filename.uploadFilename];
+                        if (mappedImage) {
+                            node.type = 'mediaSingle';
+                            node.attrs['layout'] = 'center';
+                            if (node.content) {
+                                node.content = [
+                                    {
+                                        type: 'media',
+                                        attrs: {
+                                            type: 'file',
+                                            collection: mappedImage.collection,
+                                            id: mappedImage.id,
+                                            width: mappedImage.width,
+                                            height: mappedImage.height,
+                                        },
+                                    },
+                                ];
+                            }
+                            delete node.attrs['language'];
+                            return node;
+                        }
+                    }
+                    return;
+                },
+            }) || afterAdf;
+        return afterAdf;
+    }
+}

package/dist/kroki/KrokiMermaidRenderer.d.ts

@@ -0,0 +1,7 @@
+import type { ChartData, MermaidRenderer } from '@markdown-confluence/lib';
+import { KrokiClient } from './KrokiClient.js';
+export declare class KrokiMermaidRenderer implements MermaidRenderer {
+    private client;
+    constructor(client: KrokiClient);
+    captureMermaidCharts(charts: ChartData[]): Promise<Map<string, Buffer>>;
+}

package/dist/kroki/KrokiMermaidRenderer.js

@@ -0,0 +1,13 @@
+export class KrokiMermaidRenderer {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async captureMermaidCharts(charts) {
+        const results = await Promise.all(charts.map(async (chart) => {
+            const buffer = await this.client.renderDiagram('mermaid', chart.data);
+            return [chart.name, buffer];
+        }));
+        return new Map(results);
+    }
+}

package/dist/kroki/index.d.ts

@@ -0,0 +1,3 @@
+export { KrokiClient } from './KrokiClient.js';
+export { KrokiMermaidRenderer } from './KrokiMermaidRenderer.js';
+export { KrokiDiagramPlugin } from './KrokiDiagramPlugin.js';

package/dist/kroki/index.js

@@ -0,0 +1,3 @@
+export { KrokiClient } from './KrokiClient.js';
+export { KrokiMermaidRenderer } from './KrokiMermaidRenderer.js';
+export { KrokiDiagramPlugin } from './KrokiDiagramPlugin.js';

package/docker/kroki/docker-compose.yml

@@ -0,0 +1,15 @@
+services:
+  kroki:
+    image: yuzutech/kroki
+    ports:
+      - "8371:8000"
+    restart: unless-stopped
+    environment:
+      - KROKI_MERMAID_HOST=mermaid
+    depends_on:
+      - mermaid
+  mermaid:
+    image: yuzutech/kroki-mermaid
+    restart: unless-stopped
+    expose:
+      - "8002"

package/package.json

@@ -1,20 +1,25 @@
 {
   "name": "@neverprepared/mcp-markdown-to-confluence",
-  "version": "1.0.1",
-  "description": "MCP server for converting markdown to Confluence ADF and publishing pages with mermaid diagram support",
+  "version": "1.1.1",
+  "description": "MCP server for converting markdown to Confluence ADF and publishing pages with diagram support via Kroki",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
     "mcp-markdown-to-confluence": "dist/index.js"
   },
+  "files": [
+    "dist",
+    "docker",
+    "scripts"
+  ],
   "scripts": {
     "build": "tsc",
     "start": "node dist/index.js",
-    "dev": "node --watch dist/index.js"
+    "dev": "node --watch dist/index.js",
+    "postinstall": "sh scripts/postinstall.sh"
   },
   "dependencies": {
     "@markdown-confluence/lib": "^5.5.2",
-    "@markdown-confluence/mermaid-puppeteer-renderer": "^5.5.2",
     "@modelcontextprotocol/sdk": "^1.10.1",
     "confluence.js": "^1.6.3",
     "gray-matter": "^4.0.3",
@@ -41,6 +46,8 @@
     "markdown",
     "atlassian",
     "mermaid",
+    "kroki",
+    "diagrams",
     "model-context-protocol"
   ],
   "license": "MIT"

package/scripts/postinstall.sh

@@ -0,0 +1,20 @@
+#!/bin/sh
+# Copy docker-compose files to ~/.config/neverprepared-mcp-servers/
+# Only copies if the target file does not already exist (preserves user modifications)
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+CONFIG_DIR="${HOME}/.config/neverprepared-mcp-servers"
+
+# Kroki
+KROKI_DIR="${CONFIG_DIR}/kroki"
+KROKI_SOURCE="${SCRIPT_DIR}/../docker/kroki/docker-compose.yml"
+KROKI_TARGET="${KROKI_DIR}/docker-compose.yml"
+
+if [ -f "$KROKI_SOURCE" ]; then
+  mkdir -p "$KROKI_DIR"
+  if [ ! -f "$KROKI_TARGET" ]; then
+    cp "$KROKI_SOURCE" "$KROKI_TARGET"
+    echo "mcp-markdown-to-confluence: Installed Kroki docker-compose.yml to ${KROKI_TARGET}"
+    echo "mcp-markdown-to-confluence: Run 'docker compose -f ${KROKI_TARGET} up -d' to start Kroki"
+  fi
+fi

package/.github/workflows/ci.yml

@@ -1,28 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-    branches: [main]
-
-jobs:
-  ci:
-    name: Build
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 20
-          cache: npm
-
-      - name: Install dependencies
-        run: npm ci
-        env:
-          PUPPETEER_SKIP_DOWNLOAD: "true"
-
-      - name: Build
-        run: npm run build

package/.github/workflows/release-please.yml

@@ -1,48 +0,0 @@
-name: Release Please
-
-on:
-  push:
-    branches: [main]
-
-permissions:
-  contents: write
-  pull-requests: write
-  packages: write
-
-jobs:
-  release-please:
-    runs-on: ubuntu-latest
-    outputs:
-      release_created: ${{ steps.release.outputs.release_created }}
-    steps:
-      - uses: googleapis/release-please-action@v4
-        id: release
-        with:
-          release-type: node
-
-  publish:
-    runs-on: ubuntu-latest
-    needs: release-please
-    if: needs.release-please.outputs.release_created == 'true'
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 20
-          cache: npm
-          registry-url: https://registry.npmjs.org/
-
-      - name: Install dependencies
-        run: npm ci
-        env:
-          PUPPETEER_SKIP_DOWNLOAD: "true"
-
-      - name: Build
-        run: npm run build
-
-      - name: Publish to npm
-        run: npm publish --access public
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/CHANGELOG.md

@@ -1,16 +0,0 @@
-# Changelog
-
-## [1.0.1](https://github.com/neverprepared/mcp-markdown-to-confluence/compare/v1.0.0...v1.0.1) (2026-04-01)
-
-
-### Bug Fixes
-
-* resolve packages from npm registry and fix API compatibility ([7b36bd7](https://github.com/neverprepared/mcp-markdown-to-confluence/commit/7b36bd78f9f0ad07c2e0e60658584b443215668e))
-* skip Puppeteer Chromium download in CI ([31da53d](https://github.com/neverprepared/mcp-markdown-to-confluence/commit/31da53d48ea88b5444df5715bf414a4d4d70cca5))
-
-## 1.0.0 (2026-04-01)
-
-
-### Bug Fixes
-
-* resolve packages from npm registry and fix API compatibility ([7b36bd7](https://github.com/neverprepared/mcp-markdown-to-confluence/commit/7b36bd78f9f0ad07c2e0e60658584b443215668e))

package/src/index.ts

@@ -1,482 +0,0 @@
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-} from '@modelcontextprotocol/sdk/types.js';
-import { z } from 'zod';
-import { ConfluenceClient } from 'confluence.js';
-import matter from 'gray-matter';
-import { readFile } from 'fs/promises';
-
-import {
-  parseMarkdownToADF,
-  renderADFDoc,
-  executeADFProcessingPipeline,
-  createPublisherFunctions,
-} from '@markdown-confluence/lib';
-import { MermaidRendererPlugin } from '@markdown-confluence/lib';
-import { PuppeteerMermaidRenderer } from '@markdown-confluence/mermaid-puppeteer-renderer';
-
-// ---------------------------------------------------------------------------
-// Environment
-// ---------------------------------------------------------------------------
-
-const CONFLUENCE_BASE_URL = process.env.CONFLUENCE_BASE_URL ?? '';
-const CONFLUENCE_USERNAME = process.env.CONFLUENCE_USERNAME ?? '';
-const CONFLUENCE_API_TOKEN = process.env.CONFLUENCE_API_TOKEN ?? '';
-
-// ---------------------------------------------------------------------------
-// Confluence client
-// ---------------------------------------------------------------------------
-
-const confluenceClient = new ConfluenceClient({
-  host: CONFLUENCE_BASE_URL,
-  authentication: {
-    basic: {
-      email: CONFLUENCE_USERNAME,
-      apiToken: CONFLUENCE_API_TOKEN,
-    },
-  },
-});
-
-// ---------------------------------------------------------------------------
-// Stub LoaderAdaptor — only uploadBuffer is called by the mermaid plugin
-// ---------------------------------------------------------------------------
-
-const stubAdaptor = {
-  readFile: async (_filePath: string) => undefined,
-  readBinary: async (_filePath: string) => false as const,
-  fileExists: async (_filePath: string) => false,
-  listFiles: async () => [],
-  uploadBuffer: async (
-    _buffer: Buffer,
-    _fileName: string,
-    _mimeType: string
-  ) => undefined,
-} as unknown as import('@markdown-confluence/lib').LoaderAdaptor;
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function countMermaidBlocks(adf: unknown): number {
-  if (typeof adf !== 'object' || adf === null) return 0;
-
-  const node = adf as Record<string, unknown>;
-  let count = 0;
-
-  if (
-    node['type'] === 'codeBlock' &&
-    typeof node['attrs'] === 'object' &&
-    node['attrs'] !== null &&
-    (node['attrs'] as Record<string, unknown>)['language'] === 'mermaid'
-  ) {
-    count += 1;
-  }
-
-  for (const value of Object.values(node)) {
-    if (Array.isArray(value)) {
-      for (const item of value) {
-        count += countMermaidBlocks(item);
-      }
-    } else if (typeof value === 'object' && value !== null) {
-      count += countMermaidBlocks(value);
-    }
-  }
-
-  return count;
-}
-
-// ---------------------------------------------------------------------------
-// Core publish logic
-// ---------------------------------------------------------------------------
-
-async function publishMarkdown(
-  markdown: string,
-  title: string,
-  spaceKey: string,
-  pageId?: string,
-  parentId?: string,
-  skipPreview = false
-): Promise<{ isPreview: boolean; previewText?: string; mermaidCount?: number; pageId?: string; version?: number; url?: string }> {
-  // Parse markdown → ADF
-  const adf = parseMarkdownToADF(
-    markdown,
-    CONFLUENCE_BASE_URL
-  ) as unknown as any;
-
-  const mermaidCount = countMermaidBlocks(adf);
-
-  if (!skipPreview) {
-    const previewText = renderADFDoc(adf as unknown as any);
-    return { isPreview: true, previewText, mermaidCount };
-  }
-
-  // ----- Full publish -----
-
-  let currentVersion = 1;
-  let resolvedPageId = pageId;
-
-  if (resolvedPageId) {
-    // Fetch existing page to get current version
-    const existingPage = await confluenceClient.content.getContentById({
-      id: resolvedPageId,
-      expand: ['version'],
-    });
-    currentVersion = existingPage.version!.number!;
-  } else {
-    // Create a placeholder page to obtain a pageId
-    const blankAdf = {
-      version: 1,
-      type: 'doc',
-      content: [],
-    };
-
-    const createParams: Parameters<typeof confluenceClient.content.createContent>[0] = {
-      space: { key: spaceKey },
-      title,
-      type: 'page',
-      body: {
-        atlas_doc_format: {
-          value: JSON.stringify(blankAdf),
-          representation: 'atlas_doc_format',
-        },
-      },
-    };
-
-    if (parentId) {
-      createParams.ancestors = [{ id: parentId }];
-    }
-
-    const created = await confluenceClient.content.createContent(createParams);
-    resolvedPageId = created.id!;
-    currentVersion = created.version!.number!;
-  }
-
-  // Fetch current attachments to build the map
-  const attachmentsResult = await confluenceClient.contentAttachments.getAttachments({
-    id: resolvedPageId,
-  });
-
-  type CurrentAttachments = Record<
-    string,
-    { filehash: string; attachmentId: string; collectionName: string }
-  >;
-
-  const currentAttachments: CurrentAttachments = {};
-  for (const att of attachmentsResult.results ?? []) {
-    const attTitle = att.title ?? '';
-    const fileId = (att.extensions as any)?.fileId ?? '';
-    const collectionName = (att.extensions as any)?.collectionName ?? '';
-    if (attTitle) {
-      currentAttachments[attTitle] = {
-        filehash: (att.metadata as any)?.comment ?? '',
-        attachmentId: fileId,
-        collectionName,
-      };
-    }
-  }
-
-  // Build publisher functions
-  const publisherFunctions = createPublisherFunctions(
-    confluenceClient as unknown as any,
-    stubAdaptor,
-    resolvedPageId,
-    title,
-    currentAttachments
-  );
-
-  // Run ADF processing pipeline (renders mermaid diagrams)
-  const finalAdf = await executeADFProcessingPipeline(
-    [new MermaidRendererPlugin(new PuppeteerMermaidRenderer())],
-    adf as unknown as any,
-    publisherFunctions
-  );
-
-  // Update the page with the final ADF
-  const updateParams: Parameters<typeof confluenceClient.content.updateContent>[0] = {
-    id: resolvedPageId,
-    title,
-    type: 'page',
-    version: { number: currentVersion + 1 },
-    body: {
-      atlas_doc_format: {
-        value: JSON.stringify(finalAdf),
-        representation: 'atlas_doc_format',
-      },
-    },
-  };
-
-  if (parentId) {
-    updateParams.ancestors = [{ id: parentId }];
-  }
-
-  await confluenceClient.content.updateContent(updateParams);
-
-  const url = `${CONFLUENCE_BASE_URL}/wiki/spaces/${spaceKey}/pages/${resolvedPageId}`;
-
-  return {
-    isPreview: false,
-    pageId: resolvedPageId,
-    version: currentVersion + 1,
-    mermaidCount,
-    url,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// MCP Server
-// ---------------------------------------------------------------------------
-
-const server = new Server(
-  { name: 'mcp-markdown-to-confluence', version: '1.0.0' },
-  { capabilities: { tools: {} } }
-);
-
-// Tool definitions
-server.setRequestHandler(ListToolsRequestSchema, async () => ({
-  tools: [
-    {
-      name: 'markdown_preview',
-      description:
-        'Convert markdown to Confluence ADF and return a text preview. Does not publish to Confluence.',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          markdown: { type: 'string', description: 'Markdown content to preview' },
-          title: { type: 'string', description: 'Page title (used during ADF conversion)' },
-        },
-        required: ['markdown', 'title'],
-      },
-    },
-    {
-      name: 'markdown_publish',
-      description:
-        'Publish markdown to a Confluence page. By default runs a preview first; set skip_preview: true to publish immediately.',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          markdown: { type: 'string', description: 'Markdown content to publish' },
-          title: { type: 'string', description: 'Confluence page title' },
-          spaceKey: { type: 'string', description: 'Confluence space key (e.g. "ENG")' },
-          pageId: {
-            type: 'string',
-            description: 'Existing page ID to update (omit to create a new page)',
-          },
-          parentId: {
-            type: 'string',
-            description: 'Parent page ID for new page creation',
-          },
-          skip_preview: {
-            type: 'boolean',
-            description: 'Set to true to skip preview and publish immediately',
-            default: false,
-          },
-        },
-        required: ['markdown', 'title', 'spaceKey'],
-      },
-    },
-    {
-      name: 'markdown_publish_file',
-      description:
-        'Read a markdown file from disk and publish it to Confluence. Frontmatter keys: connie-title / title, connie-space-key, connie-page-id.',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          filePath: { type: 'string', description: 'Absolute path to the markdown file' },
-          skip_preview: {
-            type: 'boolean',
-            description: 'Set to true to skip preview and publish immediately',
-            default: false,
-          },
-        },
-        required: ['filePath'],
-      },
-    },
-  ],
-}));
-
-// Tool handlers
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-  const { name, arguments: args } = request.params;
-
-  try {
-    if (name === 'markdown_preview') {
-      const input = z
-        .object({ markdown: z.string(), title: z.string() })
-        .parse(args);
-
-      const adf = parseMarkdownToADF(
-        input.markdown,
-        CONFLUENCE_BASE_URL
-      ) as unknown as any;
-
-      const mermaidCount = countMermaidBlocks(adf);
-      const previewText = renderADFDoc(adf as unknown as any);
-
-      const lines: string[] = [previewText];
-      if (mermaidCount > 0) {
-        lines.push(
-          `\n[Note: ${mermaidCount} mermaid diagram(s) detected — they will be rendered as images when published.]`
-        );
-      }
-
-      return { content: [{ type: 'text', text: lines.join('') }] };
-    }
-
-    if (name === 'markdown_publish') {
-      const input = z
-        .object({
-          markdown: z.string(),
-          title: z.string(),
-          spaceKey: z.string(),
-          pageId: z.string().optional(),
-          parentId: z.string().optional(),
-          skip_preview: z.boolean().default(false),
-        })
-        .parse(args);
-
-      const result = await publishMarkdown(
-        input.markdown,
-        input.title,
-        input.spaceKey,
-        input.pageId,
-        input.parentId,
-        input.skip_preview
-      );
-
-      if (result.isPreview) {
-        const lines: string[] = ['=== PREVIEW ===\n', result.previewText ?? ''];
-        if ((result.mermaidCount ?? 0) > 0) {
-          lines.push(
-            `\n[Note: ${result.mermaidCount} mermaid diagram(s) detected — they will be rendered when published.]`
-          );
-        }
-        lines.push(
-          '\n\nCall again with skip_preview: true to publish to Confluence.'
-        );
-        return { content: [{ type: 'text', text: lines.join('') }] };
-      }
-
-      return {
-        content: [
-          {
-            type: 'text',
-            text: [
-              `Successfully published to Confluence.`,
-              `Title: ${input.title}`,
-              `Page ID: ${result.pageId}`,
-              `Version: ${result.version}`,
-              `Mermaid diagrams rendered: ${result.mermaidCount}`,
-              `URL: ${result.url}`,
-            ].join('\n'),
-          },
-        ],
-      };
-    }
-
-    if (name === 'markdown_publish_file') {
-      const input = z
-        .object({
-          filePath: z.string(),
-          skip_preview: z.boolean().default(false),
-        })
-        .parse(args);
-
-      const raw = await readFile(input.filePath, 'utf-8');
-      const parsed = matter(raw);
-
-      const title: string =
-        parsed.data['connie-title'] ?? parsed.data['title'] ?? '';
-      const spaceKey: string = parsed.data['connie-space-key'] ?? '';
-      const pageId: string | undefined = parsed.data['connie-page-id']
-        ? String(parsed.data['connie-page-id'])
-        : undefined;
-
-      if (!title) {
-        return {
-          isError: true,
-          content: [
-            {
-              type: 'text',
-              text: 'Error: Missing page title. Set "connie-title" or "title" in frontmatter.',
-            },
-          ],
-        };
-      }
-
-      if (!spaceKey) {
-        return {
-          isError: true,
-          content: [
-            {
-              type: 'text',
-              text: 'Error: Missing space key. Set "connie-space-key" in frontmatter.',
-            },
-          ],
-        };
-      }
-
-      const result = await publishMarkdown(
-        parsed.content,
-        title,
-        spaceKey,
-        pageId,
-        undefined,
-        input.skip_preview
-      );
-
-      if (result.isPreview) {
-        const lines: string[] = [
-          `File: ${input.filePath}\n`,
-          '=== PREVIEW ===\n',
-          result.previewText ?? '',
-        ];
-        if ((result.mermaidCount ?? 0) > 0) {
-          lines.push(
-            `\n[Note: ${result.mermaidCount} mermaid diagram(s) detected — they will be rendered when published.]`
-          );
-        }
-        lines.push(
-          '\n\nCall again with skip_preview: true to publish to Confluence.'
-        );
-        return { content: [{ type: 'text', text: lines.join('') }] };
-      }
-
-      return {
-        content: [
-          {
-            type: 'text',
-            text: [
-              `Successfully published "${title}" to Confluence.`,
-              `File: ${input.filePath}`,
-              `Page ID: ${result.pageId}`,
-              `Version: ${result.version}`,
-              `Mermaid diagrams rendered: ${result.mermaidCount}`,
-              `URL: ${result.url}`,
-            ].join('\n'),
-          },
-        ],
-      };
-    }
-
-    return {
-      isError: true,
-      content: [{ type: 'text', text: `Error: Unknown tool "${name}"` }],
-    };
-  } catch (err: unknown) {
-    const message = err instanceof Error ? err.message : String(err);
-    return {
-      isError: true,
-      content: [{ type: 'text', text: `Error: ${message}` }],
-    };
-  }
-});
-
-// ---------------------------------------------------------------------------
-// Start
-// ---------------------------------------------------------------------------
-
-const transport = new StdioServerTransport();
-await server.connect(transport);

package/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "node",
-    "allowSyntheticDefaultImports": true,
-    "esModuleInterop": true,
-    "strict": true,
-    "skipLibCheck": true,
-    "declaration": true,
-    "outDir": "./dist",
-    "rootDir": "./src"
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}