@crypto512/jicon-mcp 0.7.1 → 1.0.0

package/dist/confluence/tools.js

@@ -3,110 +3,155 @@
  */
 import { z } from "zod";
 import { formatSuccess, formatError, isApiError } from "../utils/response-formatter.js";
-import { formatPageMetadata, formatSearchResults, formatSpace, } from "./formatters.js";
+import { contentBuffer } from "../utils/content-buffer.js";
+import { formatPageMetadata } from "./formatters.js";
+import { validateXhtmlAsync } from "../utils/xhtml/index.js";
+import { detectRawPlantUml } from "../utils/xhtml/plantuml.js";
+/**
+ * Resolve content from either direct content string or bufferId.
+ * Returns { content, error } - if error is set, return it as the tool result.
+ */
+function resolveContentFromBuffer(contentArg, bufferIdArg) {
+    // Exactly one of content or bufferId must be provided
+    if (contentArg && bufferIdArg) {
+        return {
+            error: formatError({
+                error: true,
+                message: "Provide either 'content' or 'bufferId', not both",
+                statusCode: 400,
+            }),
+        };
+    }
+    if (bufferIdArg) {
+        const bufferChunk = contentBuffer.getChunk(bufferIdArg);
+        if (!bufferChunk) {
+            return {
+                error: formatError({
+                    error: true,
+                    message: `Buffer ${bufferIdArg} not found or expired`,
+                    statusCode: 404,
+                }),
+            };
+        }
+        // Validate that buffer contains XHTML content for Confluence
+        const bufferInfo = contentBuffer.getInfo(bufferIdArg);
+        if (bufferInfo?.metadata?.contentType && bufferInfo.metadata.contentType !== "xhtml") {
+            return {
+                error: formatError({
+                    error: true,
+                    message: `Buffer ${bufferIdArg} contains ${bufferInfo.metadata.contentType} content, but Confluence requires XHTML.`,
+                    statusCode: 400,
+                    details: {
+                        hint: "Create Confluence content with buffer_create, then edit with buffer_edit_xhtml.",
+                        foundContentType: bufferInfo.metadata.contentType,
+                        expectedContentType: "xhtml",
+                    },
+                }),
+            };
+        }
+        // Get full content from buffer
+        const fullContent = contentBuffer.getChunk(bufferIdArg, 0, bufferChunk.totalSize);
+        if (!fullContent) {
+            return {
+                error: formatError({
+                    error: true,
+                    message: "Failed to retrieve full buffer content",
+                    statusCode: 500,
+                }),
+            };
+        }
+        return { content: fullContent.chunk };
+    }
+    // Direct content provided
+    return { content: contentArg };
+}
+/**
+ * Validate XHTML content before Confluence write operations.
+ * Returns error result if validation fails, null if valid.
+ */
+async function validateContentForWrite(content) {
+    const validation = await validateXhtmlAsync(content, { validatePlantUml: true });
+    if (!validation.valid) {
+        const errorMessages = [];
+        // XHTML structure errors
+        if (validation.errors && validation.errors.length > 0) {
+            errorMessages.push("XHTML validation errors:");
+            validation.errors.forEach((err) => {
+                const location = err.location?.line ? ` (line ${err.location.line}${err.location?.column ? `:${err.location.column}` : ""})` : "";
+                errorMessages.push(`  - ${err.message}${location}`);
+                // Include context snippet if available
+                if (err.location?.context) {
+                    const contextPreview = err.location.context.length > 60
+                        ? err.location.context.substring(0, 60) + "..."
+                        : err.location.context;
+                    errorMessages.push(`    Near: "${contextPreview}"`);
+                }
+            });
+        }
+        // PlantUML validation errors
+        if (validation.plantuml && validation.plantuml.length > 0) {
+            const invalidPlantUml = validation.plantuml.filter(p => !p.valid);
+            if (invalidPlantUml.length > 0) {
+                errorMessages.push("PlantUML validation errors:");
+                invalidPlantUml.forEach((p) => {
+                    errorMessages.push(`  Macro #${p.macroIndex + 1}:`);
+                    p.errors?.forEach((err) => {
+                        const location = err.line ? ` (line ${err.line}${err.column ? `:${err.column}` : ""})` : "";
+                        errorMessages.push(`    - ${err.message}${location}`);
+                    });
+                });
+                // Add PlantUML format example
+                errorMessages.push("");
+                errorMessages.push("Correct PlantUML macro format:");
+                errorMessages.push('  <ac:structured-macro ac:name="plantuml" ac:schema-version="1">');
+                errorMessages.push("    <ac:plain-text-body><![CDATA[");
+                errorMessages.push("  @startuml");
+                errorMessages.push("  (your diagram code)");
+                errorMessages.push("  @enduml");
+                errorMessages.push("  ]]></ac:plain-text-body>");
+                errorMessages.push("  </ac:structured-macro>");
+            }
+        }
+        // Add help hints
+        errorMessages.push("");
+        errorMessages.push('TIP: Call help(topic="storage") for Confluence XHTML format guide.');
+        errorMessages.push('TIP: Call help(topic="plantuml") for PlantUML macro examples.');
+        errorMessages.push("");
+        errorMessages.push("ACTION REQUIRED: Fix content errors before calling this tool again.");
+        errorMessages.push("DO NOT claim success - the draft was NOT created.");
+        return formatError({
+            error: true,
+            message: "Content validation failed. Fix errors before writing to Confluence.",
+            statusCode: 400,
+            details: {
+                validationErrors: errorMessages,
+                hint: "Use buffer_validate_xhtml to check content, or plantuml_validate for PlantUML syntax",
+            },
+        });
+    }
+    return null; // Valid content
+}
 export function createConfluenceTools(client) {
     return {
-        confluence_cql_help: {
-            description: "Get CQL (Confluence Query Language) syntax guide and examples.",
-            inputSchema: z.object({}),
-            handler: async () => {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `# CQL Syntax Guide
-
-## Operators
-- Text search: text~"term" (searches both title and body)
-- Title only: title~"term"
-- By space: space=KEY (use space KEY, not name!)
-- By type: type=page or type=blogpost
-- Combine: AND, OR, NOT
-- Order: ORDER BY created/lastmodified ASC/DESC
-
-## Critical Warnings
-⚠️ Do NOT use 'content~' or 'body~' - they're invalid! Use 'text~' instead.
-
-⚠️ WRONG: text~("term1" OR "term2") - Cannot use OR inside the operator
-✅ RIGHT: (text~"term1" OR text~"term2") - Each term needs its own text~ operator
-
-## Common Examples
-1. Recently updated pages (last 7 days):
-   type=page AND lastmodified >= now("-7d")
-
-2. Pages created by a person:
-   type=page AND creator="username"
-
-3. Pages with specific label:
-   type=page AND label="meeting-notes"
-
-4. Pages in space modified recently:
-   space=DOCS AND lastmodified >= now("-30d") ORDER BY lastmodified DESC
-
-5. Text search in a space:
-   text~"API" AND space=DOCS AND type=page
-
-6. Date range:
-   lastmodified >= "2025-01-01" AND lastmodified <= "2025-01-31"
-
-7. Multiple spaces:
-   space IN (DOCS, PROJ, WIKI)
-
-8. Pages by title pattern:
-   type=page AND title~"Sprint Review" ORDER BY created DESC
-
-9. Find by creator name:
-   creator.fullname~"John Smith"
-
-10. Pages created this week:
-    type=page AND created >= startOfWeek()
-
-## Tips
-- Use space KEY (e.g., 'DOCS') not space name (e.g., 'Documentation')
-- Date functions: now(), startOfDay(), startOfWeek(), startOfMonth()
-- Relative dates: now("-7d") = 7 days ago
-- Use fetchAll=true to retrieve all matching results (up to 5000)`,
-                        },
-                    ],
-                };
-            },
-        },
         confluence_search_content: {
-            description: `Search Confluence content using CQL. Set fetchAll=true for all results (up to 5000).
+            description: `Search Confluence content using CQL. Auto-fetches all results (up to 5000).
+
+BEFORE USING: Call help(topic="cql") for CQL syntax guide.
 
 Example: type=page AND space=DOCS AND text~"API" ORDER BY lastmodified DESC
 
-⚠️ Use text~ (not content~ or body~). Use space KEY (not name).
-For full CQL syntax guide, use confluence_cql_help.
+WARNING: Use text~ (not content~ or body~). Use space KEY (not name).
 
 Large responses are buffered - use buffer_get_chunk or buffer_grep to access.`,
             inputSchema: z.object({
                 cql: z.string().describe("CQL query string"),
-                limit: z.number().optional().describe("Maximum number of results per page (default: 25). When fetchAll=true, this is the maximum total results (default: 5000)."),
                 expand: z.array(z.string()).optional().describe("Additional data to expand"),
-                start: z.number().optional().describe("Index of first result (0-based, default: 0). Ignored when fetchAll=true."),
-                fetchAll: z.boolean().optional().describe("Automatically fetch all results across multiple pages (default: false, max: 5000)"),
             }),
             handler: async (args) => {
                 try {
-                    let result;
-                    if (args.fetchAll) {
-                        // Auto-fetch all results
-                        const maxTotal = args.limit || 5000;
-                        result = await client.searchContentAll(args.cql, args.expand, maxTotal);
-                    }
-                    else {
-                        // Single page
-                        result = await client.searchContent(args.cql, args.limit, args.expand, args.start);
-                    }
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: formatSearchResults(result),
-                            },
-                        ],
-                    };
+                    const result = await client.searchContentAll(args.cql, args.expand);
+                    // Use formatSuccess for automatic buffering of large responses
+                    return formatSuccess(result);
                 }
                 catch (error) {
                     // Enhanced error handling for common CQL errors
@@ -163,8 +208,8 @@ Large responses are buffered - use buffer_get_chunk or buffer_grep to access.`,
 
 PREFERRED method when you have a page ID from search results. Faster and more reliable than get_page_by_title.
 
-Returns full page data including content. Large responses are automatically buffered - use buffer_get_chunk or buffer_grep to access.
-For complex analysis, spawn a sub-agent with the bufferId.`,
+Returns pageId, version, and bufferId containing the page content.
+Use bufferId with buffer_edit/buffer_edit_xhtml to modify, then confluence_draft_create for user review.`,
             inputSchema: z.object({
                 pageId: z.coerce.string().describe("Page ID (accepts string or number)"),
                 expand: z
@@ -175,10 +220,23 @@ For complex analysis, spawn a sub-agent with the bufferId.`,
             handler: async (args) => {
                 try {
                     const result = await client.getPage(args.pageId, args.expand);
+                    const content = result.body?.storage?.value || "";
+                    // Always store content in buffer for consistent editing workflow
+                    const bufferId = contentBuffer.store(content, {
+                        resourceType: "confluence_page",
+                        resourceId: String(result.id),
+                        contentType: "xhtml",
+                        version: result.version?.number,
+                        spaceKey: result.space?.key,
+                        title: result.title,
+                    });
                     return formatSuccess({
                         ...formatPageMetadata(result),
-                        content: result.body?.storage?.value || "",
-                        data: result,
+                        pageId: result.id,
+                        version: result.version?.number,
+                        bufferId,
+                        contentSize: content.length,
+                        message: "Page loaded. Use buffer_edit_xhtml to modify, then confluence_draft_create for user review.",
                     });
                 }
                 catch (error) {
@@ -191,8 +249,8 @@ For complex analysis, spawn a sub-agent with the bufferId.`,
 
 Use ONLY when you don't have a page ID. IMPORTANT: Use the space KEY (e.g. 'MESH', 'TC'), NOT the space name.
 
-Returns full page data including content. Large responses are automatically buffered - use buffer_get_chunk or buffer_grep to access.
-For complex analysis, spawn a sub-agent with the bufferId.`,
+Returns pageId, version, and bufferId containing the page content.
+Use bufferId with buffer_edit/buffer_edit_xhtml to modify, then confluence_draft_create for user review.`,
             inputSchema: z.object({
                 spaceKey: z.string().describe("Space key (short code like 'MESH', 'TC'), NOT the full space name"),
                 title: z.string().describe("Page title"),
@@ -208,10 +266,23 @@ For complex analysis, spawn a sub-agent with the bufferId.`,
                             statusCode: 404,
                         });
                     }
+                    const content = result.body?.storage?.value || "";
+                    // Always store content in buffer for consistent editing workflow
+                    const bufferId = contentBuffer.store(content, {
+                        resourceType: "confluence_page",
+                        resourceId: String(result.id),
+                        contentType: "xhtml",
+                        version: result.version?.number,
+                        spaceKey: result.space?.key,
+                        title: result.title,
+                    });
                     return formatSuccess({
                         ...formatPageMetadata(result),
-                        content: result.body?.storage?.value || "",
-                        data: result,
+                        pageId: result.id,
+                        version: result.version?.number,
+                        bufferId,
+                        contentSize: content.length,
+                        message: "Page loaded. Use buffer_edit_xhtml to modify, then confluence_draft_create for user review.",
                     });
                 }
                 catch (error) {
@@ -219,51 +290,9 @@ For complex analysis, spawn a sub-agent with the bufferId.`,
                 }
             },
         },
-        confluence_create_page: {
-            description: "Create a new Confluence page",
-            inputSchema: z.object({
-                spaceKey: z.string().describe("Space key"),
-                title: z.string().describe("Page title"),
-                content: z
-                    .string()
-                    .describe("Page content (Confluence storage format or HTML)"),
-                parentId: z.string().optional().describe("Parent page ID"),
-                labels: z.array(z.string()).optional().describe("Array of labels"),
-            }),
-            handler: async (args) => {
-                try {
-                    const result = await client.createPage(args);
-                    return formatSuccess(result);
-                }
-                catch (error) {
-                    return formatError(isApiError(error) ? error : new Error(String(error)));
-                }
-            },
-        },
-        confluence_update_page: {
-            description: "Update an existing Confluence page",
-            inputSchema: z.object({
-                pageId: z.coerce.string().describe("Page ID (accepts string or number)"),
-                title: z.string().optional().describe("New title"),
-                content: z.string().optional().describe("New content"),
-                version: z
-                    .number()
-                    .describe("Current version number (for optimistic locking)"),
-                minorEdit: z
-                    .boolean()
-                    .optional()
-                    .describe("Whether this is a minor edit"),
-            }),
-            handler: async (args) => {
-                try {
-                    const result = await client.updatePage(args.pageId, args.version, args.title, args.content, args.minorEdit);
-                    return formatSuccess(result);
-                }
-                catch (error) {
-                    return formatError(isApiError(error) ? error : new Error(String(error)));
-                }
-            },
-        },
+        // All page writes go through draft workflow: LLM creates/edits drafts, user publishes via Confluence UI
+        // - New pages: confluence_draft_create → user publishes
+        // - Existing pages: confluence_get_page → buffer_edit → confluence_draft_create → user publishes
         confluence_delete_page: {
             description: "Delete a Confluence page",
             inputSchema: z.object({
@@ -272,6 +301,11 @@ For complex analysis, spawn a sub-agent with the bufferId.`,
             handler: async (args) => {
                 try {
                     await client.deletePage(args.pageId);
+                    // Invalidate any cached buffers for this page
+                    contentBuffer.invalidateByMetadata({
+                        resourceType: "confluence_page",
+                        resourceId: args.pageId,
+                    });
                     return formatSuccess({
                         success: true,
                         message: `Page ${args.pageId} deleted successfully`,
@@ -312,14 +346,8 @@ For complex analysis, spawn a sub-agent with the bufferId.`,
             handler: async (args) => {
                 try {
                     const result = await client.getSpace(args.spaceKey, args.expand);
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: formatSpace(result),
-                            },
-                        ],
-                    };
+                    // Use formatSuccess for automatic buffering of large responses
+                    return formatSuccess(result);
                 }
                 catch (error) {
                     return formatError(isApiError(error) ? error : new Error(String(error)));
@@ -414,6 +442,337 @@ For complex analysis, spawn a sub-agent with the bufferId.`,
                 }
             },
         },
+        confluence_get_current_user_space: {
+            description: `Get the current user's personal/home Confluence space.
+
+Use this tool when the user asks about:
+- "my space", "my home space", "my personal space"
+- "confluence home", "home space"
+- "where can I write", "my confluence area"
+
+Returns the user's personal space key and details. Use this to verify your personal space before write operations when write-home restriction is enabled.`,
+            inputSchema: z.object({}),
+            handler: async () => {
+                try {
+                    const userSpace = await client.getCurrentUserSpace();
+                    if (!userSpace) {
+                        return formatError({
+                            error: true,
+                            message: "No personal space found for current user",
+                            statusCode: 404,
+                        });
+                    }
+                    return formatSuccess({
+                        spaceKey: userSpace.key,
+                        spaceName: userSpace.name,
+                        spaceType: userSpace.type,
+                        homePageId: userSpace.homepage?.id,
+                        homePageTitle: userSpace.homepage?.title,
+                        tip: "Use this spaceKey when creating pages with write-home restriction enabled",
+                    });
+                }
+                catch (error) {
+                    return formatError(isApiError(error) ? error : new Error(String(error)));
+                }
+            },
+        },
+        // ========================================
+        // Draft Tools
+        // ========================================
+        // Note: Confluence drafts cannot be updated via API, only created, read, or deleted.
+        // The workflow is: create draft → edit locally in buffer → save (delete+recreate) → publish
+        confluence_draft_create: {
+            description: `Create a Confluence draft for user review. Returns draftId, bufferId, and clickable URL.
+
+IMPORTANT: User must validate the draft in Confluence UI before publishing.
+IMPORTANT: Raw @startuml blocks are NOT supported. Use buffer_edit_xhtml with insert-plantuml operation.
+
+BEFORE USING: Call help(topic="storage") for Confluence storage format syntax.
+BEFORE USING: Call help(topic="plantuml") for diagram workflow.
+
+Workflow:
+1. Create draft with this tool → returns URL for user review
+2. User reviews draft in Confluence UI (can edit there)
+3. If user requests changes: use confluence_draft_open to get user's edits
+4. Modify with buffer_edit, then confluence_draft_save for new review
+5. User publishes manually via Confluence UI
+
+Content must be in Confluence storage format (XHTML-based).
+Provide either 'content' (string) OR 'bufferId' (from buffer_create/buffer_edit).`,
+            inputSchema: z.object({
+                spaceKey: z.string().describe("Space key"),
+                title: z.string().describe("Page title"),
+                content: z
+                    .string()
+                    .optional()
+                    .describe("Page content in Confluence storage format (XHTML-based)"),
+                bufferId: z.string().optional().describe("Buffer ID containing content (alternative to content)"),
+                parentId: z.string().optional().describe("Parent page ID"),
+                labels: z.array(z.string()).optional().describe("Array of labels"),
+            }),
+            handler: async (args) => {
+                // Resolve content from either content string or bufferId
+                const resolved = resolveContentFromBuffer(args.content, args.bufferId);
+                if (resolved.error) {
+                    return resolved.error;
+                }
+                if (!resolved.content) {
+                    return formatError({
+                        error: true,
+                        message: "Either 'content' or 'bufferId' must be provided",
+                        statusCode: 400,
+                    });
+                }
+                const content = resolved.content;
+                // Check for raw PlantUML that should use buffer_edit_xhtml instead
+                const rawPlantUml = detectRawPlantUml(content);
+                if (rawPlantUml) {
+                    return formatError({
+                        error: true,
+                        message: "Content contains raw PlantUML code that is not wrapped in a Confluence macro.",
+                        statusCode: 400,
+                        details: {
+                            hint: rawPlantUml.hint,
+                            example: "buffer_edit_xhtml(bufferId, operation='insert-plantuml', code='@startuml...@enduml', semanticPosition='after-heading:Title')",
+                        },
+                    });
+                }
+                // Validate XHTML and PlantUML content before writing
+                const validationError = await validateContentForWrite(content);
+                if (validationError) {
+                    return validationError;
+                }
+                try {
+                    const result = await client.createDraft({
+                        spaceKey: args.spaceKey,
+                        title: args.title,
+                        content,
+                        parentId: args.parentId,
+                        labels: args.labels,
+                    });
+                    // Store content in buffer for local editing
+                    const newBufferId = contentBuffer.store(content, {
+                        resourceType: "confluence_page",
+                        resourceId: result.id,
+                        contentType: "xhtml",
+                        spaceKey: result.space?.key,
+                        title: result.title,
+                        isDraft: true,
+                    });
+                    // Build the draft edit URL (drafts use resumedraft.action, not the webui link)
+                    const baseUrl = client.getBaseUrl();
+                    const draftUrl = `${baseUrl}/pages/resumedraft.action?draftId=${result.id}`;
+                    return formatSuccess({
+                        draftId: result.id,
+                        bufferId: newBufferId,
+                        title: result.title,
+                        spaceKey: result.space?.key,
+                        version: result.version?.number || 1,
+                        url: draftUrl,
+                        message: "Draft created. User should click URL to review in Confluence and publish manually.",
+                    });
+                }
+                catch (error) {
+                    return formatError(isApiError(error) ? error : new Error(String(error)));
+                }
+            },
+        },
+        confluence_draft_open: {
+            description: `Open an existing draft page for editing. Loads content into a local buffer.
+
+Use buffer_edit to modify content, then confluence_draft_save. User publishes via Confluence UI.`,
+            inputSchema: z.object({
+                draftId: z.coerce.string().describe("Draft page ID"),
+            }),
+            handler: async (args) => {
+                try {
+                    const result = await client.getDraft(args.draftId);
+                    const content = result.body?.storage?.value || "";
+                    // Store content in buffer for local editing
+                    const bufferId = contentBuffer.store(content, {
+                        resourceType: "confluence_page",
+                        resourceId: result.id,
+                        contentType: "xhtml",
+                        spaceKey: result.space?.key,
+                        title: result.title,
+                        isDraft: true,
+                    });
+                    // Build the draft edit URL
+                    const baseUrl = client.getBaseUrl();
+                    const draftUrl = `${baseUrl}/pages/resumedraft.action?draftId=${result.id}`;
+                    // Content preview (first 500 chars)
+                    const contentPreview = content.length > 500 ? content.substring(0, 500) + "..." : content;
+                    return formatSuccess({
+                        draftId: result.id,
+                        bufferId,
+                        title: result.title,
+                        spaceKey: result.space?.key,
+                        version: result.version?.number,
+                        url: draftUrl,
+                        contentPreview,
+                    });
+                }
+                catch (error) {
+                    return formatError(isApiError(error) ? error : new Error(String(error)));
+                }
+            },
+        },
+        confluence_draft_list: {
+            description: `List your draft pages. Use confluence_draft_open to load a draft for editing.`,
+            inputSchema: z.object({
+                spaceKey: z.string().optional().describe("Filter by space key"),
+                limit: z.number().optional().describe("Max results (default: 25)"),
+            }),
+            handler: async (args) => {
+                try {
+                    const result = await client.listUserDrafts(args.spaceKey, args.limit);
+                    // Build the base URL for constructing full URLs
+                    const baseUrl = client.getBaseUrl();
+                    const drafts = result.results.map((page) => ({
+                        draftId: page.id,
+                        title: page.title,
+                        spaceKey: page.space?.key || "",
+                        spaceName: page.space?.name || "",
+                        created: page.version?.when || "",
+                        url: `${baseUrl}/pages/resumedraft.action?draftId=${page.id}`,
+                    }));
+                    return formatSuccess({
+                        drafts,
+                        total: result.totalSize,
+                    });
+                }
+                catch (error) {
+                    return formatError(isApiError(error) ? error : new Error(String(error)));
+                }
+            },
+        },
+        confluence_draft_save: {
+            description: `Save buffer content to server as a new draft for user review.
+
+IMPORTANT: Raw @startuml blocks are NOT supported. Use buffer_edit_xhtml with insert-plantuml operation.
+
+Returns a new draftId and URL. Always use the returned draftId for subsequent operations.`,
+            inputSchema: z.object({
+                draftId: z.coerce.string().describe("Current draft ID"),
+                bufferId: z.string().describe("Buffer ID containing updated content"),
+                title: z.string().optional().describe("Update title (optional)"),
+            }),
+            handler: async (args) => {
+                try {
+                    // Get the existing draft to preserve metadata
+                    const existingDraft = await client.getDraft(args.draftId);
+                    const spaceKey = existingDraft.space?.key;
+                    if (!spaceKey) {
+                        return formatError({
+                            error: true,
+                            message: "Could not determine space key from existing draft",
+                            statusCode: 400,
+                        });
+                    }
+                    // Get content from buffer
+                    const bufferChunk = contentBuffer.getChunk(args.bufferId);
+                    if (!bufferChunk) {
+                        return formatError({
+                            error: true,
+                            message: `Buffer ${args.bufferId} not found or expired`,
+                            statusCode: 404,
+                        });
+                    }
+                    // Get full content from buffer
+                    const fullContent = contentBuffer.getChunk(args.bufferId, 0, bufferChunk.totalSize);
+                    if (!fullContent) {
+                        return formatError({
+                            error: true,
+                            message: "Failed to retrieve full buffer content",
+                            statusCode: 500,
+                        });
+                    }
+                    const savedContent = fullContent.chunk;
+                    // Check for raw PlantUML that should use buffer_edit_xhtml instead
+                    const rawPlantUml = detectRawPlantUml(savedContent);
+                    if (rawPlantUml) {
+                        return formatError({
+                            error: true,
+                            message: "Content contains raw PlantUML code that is not wrapped in a Confluence macro.",
+                            statusCode: 400,
+                            details: {
+                                hint: rawPlantUml.hint,
+                                example: "buffer_edit_xhtml(bufferId, operation='insert-plantuml', code='@startuml...@enduml', semanticPosition='after-heading:Title')",
+                            },
+                        });
+                    }
+                    // Validate XHTML and PlantUML content before writing
+                    const validationError = await validateContentForWrite(savedContent);
+                    if (validationError) {
+                        return validationError;
+                    }
+                    const title = args.title || existingDraft.title;
+                    // Delete old draft
+                    await client.deleteDraft(args.draftId);
+                    // Create new draft with updated content
+                    const newDraft = await client.createDraft({
+                        spaceKey,
+                        title,
+                        content: savedContent,
+                        parentId: existingDraft.ancestors?.[0]?.id,
+                    });
+                    // Update buffer metadata with new draft ID
+                    contentBuffer.invalidateByMetadata({
+                        resourceType: "confluence_page",
+                        resourceId: args.draftId,
+                    });
+                    // Store updated content with new draft ID
+                    const newBufferId = contentBuffer.store(savedContent, {
+                        resourceType: "confluence_page",
+                        resourceId: newDraft.id,
+                        contentType: "xhtml",
+                        spaceKey: newDraft.space?.key,
+                        title: newDraft.title,
+                        isDraft: true,
+                    });
+                    // Build the draft edit URL
+                    const baseUrl = client.getBaseUrl();
+                    const draftUrl = `${baseUrl}/pages/resumedraft.action?draftId=${newDraft.id}`;
+                    return formatSuccess({
+                        previousDraftId: args.draftId,
+                        newDraftId: newDraft.id,
+                        bufferId: newBufferId,
+                        title: newDraft.title,
+                        url: draftUrl,
+                        message: "Draft saved. User should click URL to review changes and publish manually via Confluence UI.",
+                    });
+                }
+                catch (error) {
+                    return formatError(isApiError(error) ? error : new Error(String(error)));
+                }
+            },
+        },
+        confluence_draft_delete: {
+            description: `Delete a draft page permanently.
+
+Drafts are NOT sent to trash - they are permanently deleted.`,
+            inputSchema: z.object({
+                draftId: z.coerce.string().describe("Draft page ID to delete"),
+            }),
+            handler: async (args) => {
+                try {
+                    await client.deleteDraft(args.draftId);
+                    // Invalidate any cached buffers for this draft
+                    contentBuffer.invalidateByMetadata({
+                        resourceType: "confluence_page",
+                        resourceId: args.draftId,
+                    });
+                    return formatSuccess({
+                        deleted: true,
+                        draftId: args.draftId,
+                        message: "Draft deleted.",
+                    });
+                }
+                catch (error) {
+                    return formatError(isApiError(error) ? error : new Error(String(error)));
+                }
+            },
+        },
     };
 }
 //# sourceMappingURL=tools.js.map