@neverprepared/mcp-markdown-to-confluence 1.1.4 → 1.3.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, relative } 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,111 @@ 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, overrides) {
+    const raw = await readFile(filePath, 'utf-8');
+    const parsed = matter(raw);
+    const title = parsed.data['connie-title'] ?? parsed.data['title'] ?? overrides?.titleFallback ?? '';
+    const spaceKey = overrides?.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 };
+}
+async function scanDirectoryTree(rootPath, spaceKey, currentPath = rootPath, depth = 0) {
+    const entries = await readdir(currentPath, { withFileTypes: true });
+    const nodes = [];
+    const skipped = [];
+    const relFromRoot = relative(rootPath, currentPath) || '.';
+    const parentRel = depth === 0 ? null : (relative(rootPath, join(currentPath, '..')) || '.');
+    // Collect subdirectories and markdown files
+    const subdirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith('.'));
+    const mdFiles = entries.filter((e) => e.isFile() && extname(e.name).toLowerCase() === '.md' && !e.name.startsWith('.'));
+    // Check for markdown files that correspond to subdirectories (e.g., "01 - Strategic.md" + "01 - Strategic/")
+    const subdirNames = new Set(subdirs.map((d) => d.name));
+    const dirMdFiles = new Set();
+    // Process markdown files
+    for (const entry of mdFiles) {
+        const filePath = join(currentPath, entry.name);
+        const stem = basename(entry.name, extname(entry.name));
+        // If this .md file has a matching subdirectory, it will be used as the directory's content
+        if (subdirNames.has(stem)) {
+            dirMdFiles.add(stem);
+            continue; // handled when processing the subdirectory
+        }
+        const result = await parseMarkdownFile(filePath, {
+            spaceKey,
+            titleFallback: stem,
+        });
+        if ('skipped' in result) {
+            skipped.push(result);
+        }
+        else {
+            nodes.push({
+                relativePath: relative(rootPath, filePath),
+                title: result.title,
+                depth,
+                parentRelativePath: depth === 0 ? null : relFromRoot,
+                markdownFile: result,
+                isDirectory: false,
+            });
+        }
+    }
+    // Process subdirectories
+    for (const dir of subdirs) {
+        const dirPath = join(currentPath, dir.name);
+        const dirRelPath = relative(rootPath, dirPath);
+        // Check for a matching .md file to use as directory content
+        const matchingMdPath = join(currentPath, dir.name + '.md');
+        let dirMarkdownFile;
+        if (dirMdFiles.has(dir.name)) {
+            const result = await parseMarkdownFile(matchingMdPath, {
+                spaceKey,
+                titleFallback: dir.name,
+            });
+            if (!('skipped' in result)) {
+                dirMarkdownFile = result;
+            }
+        }
+        nodes.push({
+            relativePath: dirRelPath,
+            title: dirMarkdownFile?.title ?? dir.name,
+            depth,
+            parentRelativePath: depth === 0 ? null : relFromRoot,
+            markdownFile: dirMarkdownFile,
+            isDirectory: true,
+        });
+        // Recurse
+        const subResult = await scanDirectoryTree(rootPath, spaceKey, dirPath, depth + 1);
+        nodes.push(...subResult.nodes);
+        skipped.push(...subResult.skipped);
+    }
+    return { nodes, skipped };
+}
 // ---------------------------------------------------------------------------
 // Core publish logic
 // ---------------------------------------------------------------------------
@@ -253,6 +359,40 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 required: ['filePath'],
             },
         },
+        {
+            name: 'markdown_publish_directory',
+            description: 'Recursively scan a directory and publish markdown files as a Confluence page tree, ' +
+                'mirroring the folder structure. Directories become parent pages; markdown files become child pages. ' +
+                'Existing pages (with connie-page-id) are updated and reparented to match the directory structure.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    directoryPath: {
+                        type: 'string',
+                        description: 'Absolute path to the root directory',
+                    },
+                    spaceKey: {
+                        type: 'string',
+                        description: 'Confluence space key. Overrides file-level connie-space-key.',
+                    },
+                    rootPageId: {
+                        type: 'string',
+                        description: 'Existing Confluence page ID to use as the root parent. If omitted, a new root page is created.',
+                    },
+                    skip_preview: {
+                        type: 'boolean',
+                        description: 'Set to true to skip preview and publish immediately',
+                        default: false,
+                    },
+                    concurrency: {
+                        type: 'number',
+                        description: 'Maximum concurrent publishes per depth level (default: 5)',
+                        default: 5,
+                    },
+                },
+                required: ['directoryPath', 'spaceKey'],
+            },
+        },
     ],
 }));
 // Tool handlers
@@ -373,6 +513,185 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 ],
             };
         }
+        if (name === 'markdown_publish_directory') {
+            const input = z
+                .object({
+                directoryPath: z.string(),
+                spaceKey: z.string(),
+                rootPageId: z.string().optional(),
+                skip_preview: z.boolean().default(false),
+                concurrency: z.number().int().min(1).max(20).default(5),
+            })
+                .parse(args);
+            // Scan directory tree
+            const { nodes, skipped } = await scanDirectoryTree(input.directoryPath, input.spaceKey);
+            if (nodes.length === 0 && skipped.length === 0) {
+                return {
+                    content: [{ type: 'text', text: `No files found in ${input.directoryPath}` }],
+                };
+            }
+            // Preview mode
+            if (!input.skip_preview) {
+                const rootTitle = input.rootPageId
+                    ? `(existing page: ${input.rootPageId})`
+                    : `"${basename(input.directoryPath)}" (will be created)`;
+                const lines = [
+                    `=== DIRECTORY TREE PREVIEW ===`,
+                    `Directory: ${input.directoryPath}`,
+                    `Space: ${input.spaceKey}`,
+                    `Root page: ${rootTitle}`,
+                    `Total pages: ${nodes.length + (input.rootPageId ? 0 : 1)}`,
+                    '',
+                    '--- Page tree ---',
+                ];
+                // Build tree visualization
+                const maxDepth = nodes.reduce((max, n) => Math.max(max, n.depth), 0);
+                for (let d = 0; d <= maxDepth; d++) {
+                    for (const node of nodes.filter((n) => n.depth === d)) {
+                        const indent = '  '.repeat(d + 1);
+                        const suffix = node.isDirectory ? '/' : '';
+                        const pageInfo = node.markdownFile?.pageId
+                            ? `update: ${node.markdownFile.pageId}`
+                            : 'new page';
+                        let diagrams = '';
+                        if (node.markdownFile) {
+                            const adf = parseMarkdownToADF(node.markdownFile.content, CONFLUENCE_BASE_URL);
+                            const count = countDiagramBlocks(adf);
+                            if (count > 0)
+                                diagrams = `, ${count} diagram(s)`;
+                        }
+                        const label = node.isDirectory && !node.markdownFile ? 'placeholder' : pageInfo;
+                        lines.push(`${indent}${node.title}${suffix} (${label}${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.`);
+                return { content: [{ type: 'text', text: lines.join('\n') }] };
+            }
+            // Publish mode — process level by level
+            const limit = pLimit(input.concurrency);
+            // Create or resolve root page
+            let rootPageId = input.rootPageId;
+            const allResults = [];
+            if (!rootPageId) {
+                try {
+                    const rootResult = await publishMarkdown('', basename(input.directoryPath), input.spaceKey, undefined, undefined, true);
+                    rootPageId = rootResult.pageId;
+                    allResults.push({
+                        relativePath: '.',
+                        title: basename(input.directoryPath),
+                        success: true,
+                        isDirectory: true,
+                        pageId: rootResult.pageId,
+                        version: rootResult.version,
+                        url: rootResult.url,
+                    });
+                }
+                catch (err) {
+                    return {
+                        isError: true,
+                        content: [{
+                                type: 'text',
+                                text: `Error creating root page: ${err instanceof Error ? err.message : String(err)}`,
+                            }],
+                    };
+                }
+            }
+            // Build a map from relativePath to node for parent lookups
+            const nodeMap = new Map();
+            for (const node of nodes) {
+                nodeMap.set(node.relativePath, node);
+            }
+            // Group by depth and process level by level
+            const maxDepth = nodes.reduce((max, n) => Math.max(max, n.depth), 0);
+            for (let depth = 0; depth <= maxDepth; depth++) {
+                const levelNodes = nodes.filter((n) => n.depth === depth);
+                const levelResults = await Promise.all(levelNodes.map((node) => limit(async () => {
+                    // Determine parent page ID
+                    let parentId;
+                    if (node.parentRelativePath === null) {
+                        parentId = rootPageId;
+                    }
+                    else {
+                        const parentNode = nodeMap.get(node.parentRelativePath);
+                        parentId = parentNode?.resolvedPageId;
+                    }
+                    if (!parentId) {
+                        return {
+                            relativePath: node.relativePath,
+                            title: node.title,
+                            success: false,
+                            isDirectory: node.isDirectory,
+                            error: 'Parent page was not created (parent failed)',
+                        };
+                    }
+                    try {
+                        const content = node.markdownFile?.content ?? '';
+                        const pageId = node.markdownFile?.pageId;
+                        const result = await publishMarkdown(content, node.title, input.spaceKey, pageId, parentId, true);
+                        // Store resolved page ID for children
+                        node.resolvedPageId = result.pageId;
+                        return {
+                            relativePath: node.relativePath,
+                            title: node.title,
+                            success: true,
+                            isDirectory: node.isDirectory,
+                            pageId: result.pageId,
+                            version: result.version,
+                            diagramCount: result.diagramCount,
+                            url: result.url,
+                        };
+                    }
+                    catch (err) {
+                        return {
+                            relativePath: node.relativePath,
+                            title: node.title,
+                            success: false,
+                            isDirectory: node.isDirectory,
+                            error: err instanceof Error ? err.message : String(err),
+                        };
+                    }
+                })));
+                allResults.push(...levelResults);
+            }
+            // Build summary
+            const succeeded = allResults.filter((r) => r.success);
+            const failed = allResults.filter((r) => !r.success);
+            const lines = [
+                `=== DIRECTORY PUBLISH RESULTS ===`,
+                `Directory: ${input.directoryPath}`,
+                `Space: ${input.spaceKey}`,
+                `Succeeded: ${succeeded.length} | Failed: ${failed.length} | Skipped: ${skipped.length}`,
+                '',
+            ];
+            if (succeeded.length > 0) {
+                lines.push('--- Succeeded ---');
+                for (const r of succeeded) {
+                    const type = r.isDirectory ? ' (folder)' : '';
+                    lines.push(`  "${r.title}"${type}`);
+                    lines.push(`    Page ID: ${r.pageId} | Version: ${r.version}${r.diagramCount ? ` | Diagrams: ${r.diagramCount}` : ''} | URL: ${r.url}`);
+                }
+            }
+            if (failed.length > 0) {
+                lines.push('', '--- Failed ---');
+                for (const r of failed) {
+                    lines.push(`  "${r.title}" (${r.relativePath})`);
+                    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.3.0",
   "description": "MCP server for converting markdown to Confluence ADF and publishing pages with diagram support via Kroki",
   "type": "module",
   "main": "dist/index.js",