@kimdayoun/hwpx-mcp 0.3.3 → 0.3.5

package/dist/HwpxParser.d.ts

@@ -31,6 +31,19 @@ export declare class HwpxParser {
     private static parseColumnDef;
     private static parseImageEffects;
     private static parseParagraphsSimple;
+    /**
+     * The paragraph with every nested container (table, text box, drawing
+     * object, header/footer, caption, equation, note…) cut out, leaving only its
+     * own runs and text. Section paragraphs are read from this: the paragraphs
+     * inside those containers are listed as elements of their own, and the save
+     * path writes a paragraph's text into exactly these own <hp:t>
+     * (HwpxDocument.ownRunText). Reading the whole paragraph instead ended its
+     * run at the first nested </hp:run>: a paragraph "[text box] own text" read
+     * as the text box's text, its own text was never seen, and a whole-paragraph
+     * edit reopened as the old text box text (CodeRabbit, PR #17; 41 of 16,733
+     * paragraphs with own text in 275 Hancom originals lost it on reading).
+     */
+    private static withoutNestedContent;
     private static parseParagraph;
     private static parseRun;
     private static processTextContent;

package/dist/HwpxParser.js

@@ -1283,7 +1283,9 @@ class HwpxParser {
         elements.sort((a, b) => a.index - b.index);
         for (const el of elements) {
             if (el.type === 'p') {
-                const paragraph = this.parseParagraph(el.xml);
+                // Own content only: the paragraphs inside its text boxes, headers and
+                // captions are elements of their own (withoutNestedContent).
+                const paragraph = this.parseParagraph(this.withoutNestedContent(el.xml));
                 // Store XML position from original XML for direct updates
                 // This enables fast paragraph updates without re-parsing during save()
                 if (el.originalXmlPosition) {
@@ -1864,6 +1866,53 @@ class HwpxParser {
         }
         return paragraphs;
     }
+    /**
+     * The paragraph with every nested container (table, text box, drawing
+     * object, header/footer, caption, equation, note…) cut out, leaving only its
+     * own runs and text. Section paragraphs are read from this: the paragraphs
+     * inside those containers are listed as elements of their own, and the save
+     * path writes a paragraph's text into exactly these own <hp:t>
+     * (HwpxDocument.ownRunText). Reading the whole paragraph instead ended its
+     * run at the first nested </hp:run>: a paragraph "[text box] own text" read
+     * as the text box's text, its own text was never seen, and a whole-paragraph
+     * edit reopened as the old text box text (CodeRabbit, PR #17; 41 of 16,733
+     * paragraphs with own text in 275 Hancom originals lost it on reading).
+     */
+    static withoutNestedContent(paragraphXml) {
+        const nested = /<hp:(tbl|subList|equation|pic|rect|ellipse|polygon|curve|arc|line|container|drawText|textart|ole|footNote|endNote|header|footer)\b/;
+        const openEnd = paragraphXml.indexOf('>') + 1;
+        let rest = paragraphXml.slice(openEnd);
+        let own = '';
+        for (;;) {
+            const m = rest.match(nested);
+            if (!m || m.index === undefined) {
+                own += rest;
+                break;
+            }
+            own += rest.slice(0, m.index);
+            const re = new RegExp(`<(/?)hp:${m[1]}\\b[^>]*?(/?)>`, 'g');
+            re.lastIndex = m.index;
+            let depth = 0;
+            let end = rest.length;
+            let t;
+            while ((t = re.exec(rest)) !== null) {
+                if (t[2]) {
+                    if (depth === 0) {
+                        end = t.index + t[0].length;
+                        break;
+                    }
+                    continue;
+                }
+                depth += t[1] ? -1 : 1;
+                if (depth === 0) {
+                    end = t.index + t[0].length;
+                    break;
+                }
+            }
+            rest = rest.slice(end);
+        }
+        return paragraphXml.slice(0, openEnd) + own;
+    }
     static parseParagraph(xml) {
         // Extract only the opening <hp:p ...> tag to get paragraph attributes
         const pTagMatch = xml.match(/^<hp:p\s+([^>]*)>/);

package/dist/ToolResult.d.ts

@@ -0,0 +1,14 @@
+/**
+ * MCP tool-result envelope and argument checks, kept out of index.ts so they
+ * can be tested without starting the stdio server.
+ */
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+export declare function success(data: unknown): CallToolResult;
+export declare function error(message: string): CallToolResult;
+/**
+ * The declared-required arguments of `toolName` that `args` leaves undefined or
+ * null. Reporting them by name replaced a generic handler failure: omitting
+ * `section_index` used to surface as "Failed to insert paragraph", which reads
+ * like document corruption.
+ */
+export declare function findMissingArgs(requiredByTool: ReadonlyMap<string, readonly string[]>, toolName: string, args: Record<string, unknown> | undefined): string[];

package/dist/ToolResult.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.success = success;
+exports.error = error;
+exports.findMissingArgs = findMissingArgs;
+function success(data) {
+    return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+}
+function error(message) {
+    // isError tells the MCP client the call failed. Without it, a missing
+    // argument or a refused write came back as a normal result whose body merely
+    // contained {"error": …}, and agents treated it as success (reported
+    // 2026-09-24). The JSON body is kept for clients that read it.
+    return { content: [{ type: 'text', text: JSON.stringify({ error: message }) }], isError: true };
+}
+/**
+ * The declared-required arguments of `toolName` that `args` leaves undefined or
+ * null. Reporting them by name replaced a generic handler failure: omitting
+ * `section_index` used to surface as "Failed to insert paragraph", which reads
+ * like document corruption.
+ */
+function findMissingArgs(requiredByTool, toolName, args) {
+    const required = requiredByTool.get(toolName);
+    if (!required || required.length === 0)
+        return [];
+    return required.filter(key => args?.[key] === undefined || args?.[key] === null);
+}

package/dist/XmlWellFormed.d.ts

@@ -0,0 +1,5 @@
+import type JSZip from 'jszip';
+/** First well-formedness error in `xml`, or null when it parses. */
+export declare function xmlWellFormednessError(xml: string): string | null;
+/** Every `.xml` / `.hpf` part of the package that does not parse, as "path: error". */
+export declare function findMalformedXmlParts(zip: JSZip): Promise<string[]>;

package/dist/XmlWellFormed.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xmlWellFormednessError = xmlWellFormednessError;
+exports.findMalformedXmlParts = findMalformedXmlParts;
+/**
+ * Well-formedness check for the XML parts of a saved HWPX package.
+ *
+ * save_document(verify_integrity) used to look for three textual symptoms
+ * (no `<?xml`, a dangling `<` at the end, `<` inside a tag). A section with a
+ * mismatched close tag passed all three and was reported as
+ * `integrity_verified: true`, while Hancom and every XML parser rejected it
+ * (reported 2026-09-24: `<hp:p>` 5730 open / 5728 close after one edit).
+ * A real parser is the only check that means what the flag claims.
+ *
+ * Measured on 275 Hancom-saved originals (2,046 XML parts, 168 MB): 0 false
+ * rejections, ~1.5 s total. The only rejected sample was a password-protected
+ * file, whose parts are ciphertext rather than XML.
+ */
+const saxes_1 = require("saxes");
+/** First well-formedness error in `xml`, or null when it parses. */
+function xmlWellFormednessError(xml) {
+    // xmlns: true also rejects an undeclared prefix (<hs:sec> with only
+    // xmlns:hp declared). Hancom declares every prefix it uses (0 rejections
+    // across the 275-file corpus with this setting), while set_section_xml
+    // accepted a section missing xmlns:hs.
+    const parser = new saxes_1.SaxesParser({ xmlns: true });
+    let first = null;
+    parser.on('error', err => {
+        if (first === null)
+            first = err.message;
+    });
+    try {
+        parser.write(xml).close();
+    }
+    catch (err) {
+        first ?? (first = err instanceof Error ? err.message : String(err));
+    }
+    return first;
+}
+/** Every `.xml` / `.hpf` part of the package that does not parse, as "path: error". */
+async function findMalformedXmlParts(zip) {
+    const out = [];
+    const names = Object.keys(zip.files)
+        .filter(name => !zip.files[name].dir && /\.(xml|hpf)$/i.test(name))
+        .sort();
+    for (const name of names) {
+        const err = xmlWellFormednessError(await zip.file(name).async('string'));
+        if (err)
+            out.push(`${name}: ${err}`);
+    }
+    return out;
+}