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

package/bin/mcp-markdown-to-confluence.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { register } from 'node:module';
+import { pathToFileURL } from 'node:url';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+register(pathToFileURL(resolve(__dirname, '..', 'dist', 'loader.js')));
+
+await import(pathToFileURL(resolve(__dirname, '..', 'dist', 'index.js')));

package/dist/index.js

@@ -4,8 +4,14 @@ import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextpro
 import { z } from 'zod';
 import { ConfluenceClient } from 'confluence.js';
 import matter from 'gray-matter';
-import { readFile } from 'fs/promises';
-import { parseMarkdownToADF, renderADFDoc, executeADFProcessingPipeline, createPublisherFunctions, MermaidRendererPlugin, } from '@markdown-confluence/lib';
+import { readFile, readdir } from 'fs/promises';
+import { join, extname, basename } from 'path';
+// Deep imports to avoid loading adaptors/filesystem.js which has broken CJS named exports.
+// Pin @markdown-confluence/lib version if these paths change.
+import { parseMarkdownToADF } from '@markdown-confluence/lib/dist/MdToADF.js';
+import { renderADFDoc } from '@markdown-confluence/lib/dist/ADFToMarkdown.js';
+import { executeADFProcessingPipeline, createPublisherFunctions, } from '@markdown-confluence/lib/dist/ADFProcessingPlugins/types.js';
+import { MermaidRendererPlugin } from '@markdown-confluence/lib/dist/ADFProcessingPlugins/MermaidRendererPlugin.js';
 import { KrokiClient, KrokiMermaidRenderer, KrokiDiagramPlugin } from './kroki/index.js';
 // ---------------------------------------------------------------------------
 // Environment
@@ -90,6 +96,41 @@ function countDiagramBlocks(adf) {
     }
     return count;
 }
+function pLimit(concurrency) {
+    let active = 0;
+    const queue = [];
+    function next() {
+        if (queue.length > 0 && active < concurrency) {
+            active++;
+            queue.shift()();
+        }
+    }
+    return (fn) => new Promise((resolve, reject) => {
+        queue.push(() => {
+            fn().then(resolve, reject).finally(() => {
+                active--;
+                next();
+            });
+        });
+        next();
+    });
+}
+async function parseMarkdownFile(filePath) {
+    const raw = await readFile(filePath, 'utf-8');
+    const parsed = matter(raw);
+    const title = parsed.data['connie-title'] ?? parsed.data['title'] ?? '';
+    const spaceKey = parsed.data['connie-space-key'] ?? '';
+    const pageId = parsed.data['connie-page-id']
+        ? String(parsed.data['connie-page-id'])
+        : undefined;
+    if (!title) {
+        return { skipped: true, filePath, reason: 'Missing "connie-title" or "title" in frontmatter' };
+    }
+    if (!spaceKey) {
+        return { skipped: true, filePath, reason: 'Missing "connie-space-key" in frontmatter' };
+    }
+    return { filePath, title, spaceKey, pageId, content: parsed.content };
+}
 // ---------------------------------------------------------------------------
 // Core publish logic
 // ---------------------------------------------------------------------------
@@ -248,6 +289,31 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 required: ['filePath'],
             },
         },
+        {
+            name: 'markdown_publish_directory',
+            description: 'Scan a directory for markdown files with Confluence frontmatter and publish them all concurrently. ' +
+                'Files without required frontmatter (connie-title, connie-space-key) are skipped.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    directoryPath: {
+                        type: 'string',
+                        description: 'Absolute path to the directory containing markdown files',
+                    },
+                    skip_preview: {
+                        type: 'boolean',
+                        description: 'Set to true to skip preview and publish immediately',
+                        default: false,
+                    },
+                    concurrency: {
+                        type: 'number',
+                        description: 'Maximum number of files to publish concurrently (default: 5)',
+                        default: 5,
+                    },
+                },
+                required: ['directoryPath'],
+            },
+        },
     ],
 }));
 // Tool handlers
@@ -368,6 +434,114 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 ],
             };
         }
+        if (name === 'markdown_publish_directory') {
+            const input = z
+                .object({
+                directoryPath: z.string(),
+                skip_preview: z.boolean().default(false),
+                concurrency: z.number().int().min(1).max(20).default(5),
+            })
+                .parse(args);
+            const entries = await readdir(input.directoryPath);
+            const mdFiles = entries
+                .filter((f) => extname(f).toLowerCase() === '.md')
+                .map((f) => join(input.directoryPath, f));
+            if (mdFiles.length === 0) {
+                return {
+                    content: [{ type: 'text', text: `No .md files found in ${input.directoryPath}` }],
+                };
+            }
+            const parseResults = await Promise.all(mdFiles.map(parseMarkdownFile));
+            const valid = [];
+            const skipped = [];
+            for (const r of parseResults) {
+                if ('skipped' in r) {
+                    skipped.push(r);
+                }
+                else {
+                    valid.push(r);
+                }
+            }
+            if (!input.skip_preview) {
+                const lines = [
+                    `=== DIRECTORY PREVIEW ===`,
+                    `Directory: ${input.directoryPath}`,
+                    `Total .md files: ${mdFiles.length}`,
+                    `Files to publish: ${valid.length}`,
+                    `Files skipped: ${skipped.length}`,
+                    '',
+                    '--- Files to publish ---',
+                ];
+                for (const f of valid) {
+                    const adf = parseMarkdownToADF(f.content, CONFLUENCE_BASE_URL);
+                    const diagrams = countDiagramBlocks(adf);
+                    lines.push(`  ${basename(f.filePath)}`);
+                    lines.push(`    Title: ${f.title} | Space: ${f.spaceKey}` +
+                        (f.pageId ? ` | Page ID: ${f.pageId}` : ' (new page)') +
+                        (diagrams > 0 ? ` | Diagrams: ${diagrams}` : ''));
+                }
+                if (skipped.length > 0) {
+                    lines.push('', '--- Skipped files ---');
+                    for (const s of skipped) {
+                        lines.push(`  ${basename(s.filePath)}: ${s.reason}`);
+                    }
+                }
+                lines.push('', `Call again with skip_preview: true to publish all ${valid.length} file(s).`);
+                return { content: [{ type: 'text', text: lines.join('\n') }] };
+            }
+            const limit = pLimit(input.concurrency);
+            const results = await Promise.all(valid.map((f) => limit(async () => {
+                try {
+                    const result = await publishMarkdown(f.content, f.title, f.spaceKey, f.pageId, undefined, true);
+                    return {
+                        filePath: f.filePath,
+                        title: f.title,
+                        success: true,
+                        pageId: result.pageId,
+                        version: result.version,
+                        diagramCount: result.diagramCount,
+                        url: result.url,
+                    };
+                }
+                catch (err) {
+                    return {
+                        filePath: f.filePath,
+                        title: f.title,
+                        success: false,
+                        error: err instanceof Error ? err.message : String(err),
+                    };
+                }
+            })));
+            const succeeded = results.filter((r) => r.success);
+            const failed = results.filter((r) => !r.success);
+            const lines = [
+                `=== DIRECTORY PUBLISH RESULTS ===`,
+                `Directory: ${input.directoryPath}`,
+                `Succeeded: ${succeeded.length} | Failed: ${failed.length} | Skipped: ${skipped.length}`,
+                '',
+            ];
+            if (succeeded.length > 0) {
+                lines.push('--- Succeeded ---');
+                for (const r of succeeded) {
+                    lines.push(`  "${r.title}"`);
+                    lines.push(`    Page ID: ${r.pageId} | Version: ${r.version} | Diagrams: ${r.diagramCount} | URL: ${r.url}`);
+                }
+            }
+            if (failed.length > 0) {
+                lines.push('', '--- Failed ---');
+                for (const r of failed) {
+                    lines.push(`  "${r.title}" (${basename(r.filePath)})`);
+                    lines.push(`    Error: ${r.error}`);
+                }
+            }
+            if (skipped.length > 0) {
+                lines.push('', '--- Skipped (invalid frontmatter) ---');
+                for (const s of skipped) {
+                    lines.push(`  ${basename(s.filePath)}: ${s.reason}`);
+                }
+            }
+            return { content: [{ type: 'text', text: lines.join('\n') }] };
+        }
         return {
             isError: true,
             content: [{ type: 'text', text: `Error: Unknown tool "${name}"` }],

package/dist/loader.js

@@ -0,0 +1,57 @@
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { resolve as pathResolve, dirname } from 'node:path';
+import { existsSync, readFileSync } from 'node:fs';
+
+function tryResolveFile(filePath) {
+  // Direct .js extension
+  if (existsSync(filePath + '.js')) {
+    return pathToFileURL(filePath + '.js').href;
+  }
+  // Directory with index.js
+  if (existsSync(filePath + '/index.js')) {
+    return pathToFileURL(filePath + '/index.js').href;
+  }
+  // Directory with package.json (module or main field)
+  if (existsSync(filePath + '/package.json')) {
+    try {
+      const pkg = JSON.parse(readFileSync(filePath + '/package.json', 'utf-8'));
+      const entry = pkg.module || pkg.main;
+      if (entry) {
+        const resolved = pathResolve(filePath, entry);
+        if (existsSync(resolved)) {
+          return pathToFileURL(resolved).href;
+        }
+      }
+    } catch {}
+  }
+  return null;
+}
+
+export async function load(url, context, nextLoad) {
+  if (url.endsWith('.json')) {
+    return nextLoad(url, { ...context, importAttributes: { type: 'json' } });
+  }
+  return nextLoad(url, context);
+}
+
+export async function resolve(specifier, context, nextResolve) {
+  try {
+    return await nextResolve(specifier, context);
+  } catch (err) {
+    if (err?.code === 'ERR_MODULE_NOT_FOUND' || err?.code === 'ERR_UNSUPPORTED_DIR_IMPORT') {
+      // Try from the error's resolved URL
+      if (err.url) {
+        const resolved = tryResolveFile(fileURLToPath(err.url));
+        if (resolved) return { url: resolved, shortCircuit: true };
+      }
+
+      // Try from parent for relative specifiers
+      if (specifier.startsWith('.') && context.parentURL) {
+        const parentPath = dirname(fileURLToPath(context.parentURL));
+        const resolved = tryResolveFile(pathResolve(parentPath, specifier));
+        if (resolved) return { url: resolved, shortCircuit: true };
+      }
+    }
+    throw err;
+  }
+}

package/package.json

@@ -1,25 +1,26 @@
 {
   "name": "@neverprepared/mcp-markdown-to-confluence",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "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"
+    "mcp-markdown-to-confluence": "bin/mcp-markdown-to-confluence.js"
   },
   "files": [
+    "bin",
     "dist",
     "docker",
     "scripts"
   ],
   "scripts": {
-    "build": "tsc",
-    "start": "node dist/index.js",
-    "dev": "node --watch dist/index.js",
+    "build": "tsc && cp src/loader.js dist/loader.js",
+    "start": "node bin/mcp-markdown-to-confluence.js",
+    "dev": "node --watch bin/mcp-markdown-to-confluence.js",
     "postinstall": "sh scripts/postinstall.sh"
   },
   "dependencies": {
-    "@markdown-confluence/lib": "^5.5.2",
+    "@markdown-confluence/lib": "5.5.2",
     "@modelcontextprotocol/sdk": "^1.10.1",
     "confluence.js": "^1.6.3",
     "gray-matter": "^4.0.3",