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

package/dist/index.js

@@ -4,7 +4,8 @@ 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 { 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';
@@ -95,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
 // ---------------------------------------------------------------------------
@@ -253,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
@@ -373,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neverprepared/mcp-markdown-to-confluence",
-  "version": "1.1.4",
+  "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",