@wonderwhy-er/desktop-commander 0.2.38 → 0.2.40

package/dist/tools/docx/utils.js

@@ -1,299 +0,0 @@
-/**
- * DOCX Utility Functions
- * Helper functions for DOCX operations, validation, and data transformation
- */
-import fs from 'fs/promises';
-import path from 'path';
-// Import types from docx for image handling
-// @ts-ignore - docx library has incomplete type definitions but exports exist at runtime
-import * as docx from 'docx';
-const { ImageRun, } = docx;
-import { DocxError, DocxErrorCode, withErrorContext } from './errors.js';
-/**
- * Check if a string is a valid data URL
- */
-export function isDataUrl(src) {
-    return src.startsWith('data:') && src.includes('base64,');
-}
-/**
- * Check if a source is a URL (http/https)
- */
-export function isUrl(src) {
-    return src.startsWith('http://') || src.startsWith('https://');
-}
-/**
- * Parse data URL into buffer
- * @returns Buffer if successful, null if invalid
- */
-export function parseDataUrl(dataUrl) {
-    try {
-        const match = dataUrl.match(/^data:([^;]+);base64,(.+)$/);
-        if (!match)
-            return null;
-        return Buffer.from(match[2], 'base64');
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Resolve image path relative to base directory
- */
-export function resolveImagePath(imagePath, baseDir) {
-    if (path.isAbsolute(imagePath) || isUrl(imagePath) || isDataUrl(imagePath)) {
-        return imagePath;
-    }
-    if (!baseDir) {
-        return path.resolve(imagePath);
-    }
-    return path.join(baseDir, imagePath);
-}
-/**
- * Check if a file exists
- */
-export async function fileExists(filePath) {
-    try {
-        await fs.access(filePath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Validate image file
- */
-export async function validateImageFile(imagePath) {
-    if (isDataUrl(imagePath)) {
-        const buffer = parseDataUrl(imagePath);
-        if (!buffer) {
-            return { valid: false, error: 'Invalid data URL format' };
-        }
-        return { valid: true };
-    }
-    if (isUrl(imagePath)) {
-        // For URLs, we'll validate during fetch
-        return { valid: true };
-    }
-    const exists = await fileExists(imagePath);
-    if (!exists) {
-        return { valid: false, error: `Image file not found: ${imagePath}` };
-    }
-    // Check file extension
-    const ext = path.extname(imagePath).toLowerCase();
-    const validExtensions = ['.png', '.jpg', '.jpeg', '.gif', '.bmp', '.webp', '.svg'];
-    if (!validExtensions.includes(ext)) {
-        return { valid: false, error: `Unsupported image format: ${ext}` };
-    }
-    return { valid: true };
-}
-/**
- * Escape special regex characters for literal string matching
- */
-export function escapeRegExp(str) {
-    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-/**
- * Validate markdown table format
- */
-export function isValidMarkdownTable(markdown) {
-    const lines = markdown.trim().split('\n');
-    if (lines.length < 2)
-        return false;
-    // Check header row
-    const headerLine = lines[0].trim();
-    if (!headerLine.startsWith('|') || !headerLine.endsWith('|'))
-        return false;
-    // Check separator row
-    const separatorLine = lines[1].trim();
-    if (!separatorLine.startsWith('|') || !separatorLine.endsWith('|'))
-        return false;
-    // Verify separator contains dashes
-    const separatorPattern = /^(\|\s*:?-{2,}\s*:?\s*)+\|$/;
-    if (!separatorPattern.test(separatorLine))
-        return false;
-    return true;
-}
-/**
- * Build a markdown table from a 2D array of rows
- */
-export function buildMarkdownTableFromRows(rows) {
-    if (!rows || rows.length === 0) {
-        return '';
-    }
-    const header = rows[0];
-    const dataRows = rows.slice(1);
-    const headerLine = `| ${header.join(' | ')} |`;
-    const separatorLine = `| ${header.map(() => '---').join(' | ')} |`;
-    const dataLines = dataRows.map((r) => `| ${r.join(' | ')} |`);
-    return [headerLine, separatorLine, ...dataLines].join('\n');
-}
-/**
- * Parse markdown table into 2D array
- */
-export function parseMarkdownTable(markdown) {
-    if (!isValidMarkdownTable(markdown)) {
-        return null;
-    }
-    const lines = markdown.trim().split('\n');
-    const rows = [];
-    for (let i = 0; i < lines.length; i++) {
-        // Skip separator line
-        if (i === 1)
-            continue;
-        const line = lines[i].trim();
-        const cells = line
-            .replace(/^\|/, '')
-            .replace(/\|$/, '')
-            .split('|')
-            .map(cell => cell.trim());
-        rows.push(cells);
-    }
-    return rows;
-}
-/**
- * Get MIME type from file extension or data URL
- */
-export function getMimeType(source) {
-    if (isDataUrl(source)) {
-        const match = source.match(/^data:([^;]+);/);
-        return match ? match[1] : null;
-    }
-    const ext = path.extname(source).toLowerCase();
-    const mimeTypes = {
-        '.png': 'image/png',
-        '.jpg': 'image/jpeg',
-        '.jpeg': 'image/jpeg',
-        '.gif': 'image/gif',
-        '.bmp': 'image/bmp',
-        '.webp': 'image/webp',
-        '.svg': 'image/svg+xml',
-    };
-    return mimeTypes[ext] || null;
-}
-/**
- * Format file size in human-readable format
- */
-export function formatFileSize(bytes) {
-    if (bytes === 0)
-        return '0 Bytes';
-    const k = 1024;
-    const sizes = ['Bytes', 'KB', 'MB', 'GB'];
-    const i = Math.floor(Math.log(bytes) / Math.log(k));
-    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
-}
-/**
- * Normalize line endings to \n
- */
-export function normalizeLineEndings(text) {
-    return text.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
-}
-/**
- * Split markdown into lines, preserving empty lines
- */
-export function splitMarkdownLines(markdown) {
-    return normalizeLineEndings(markdown).split('\n');
-}
-/**
- * Validate DOCX file path
- */
-export function isDocxPath(filePath) {
-    return filePath.toLowerCase().endsWith('.docx');
-}
-/**
- * Extract file name without extension
- */
-export function getFileNameWithoutExtension(filePath) {
-    const basename = path.basename(filePath);
-    return basename.replace(/\.docx$/i, '');
-}
-// Re-export error handling from errors module
-export { DocxError, DocxErrorCode, withErrorContext } from './errors.js';
-/**
- * Load and prepare an image for DOCX embedding
- * Handles both local files and data URLs
- *
- * @param imagePath - Path to image file or data URL
- * @param altText - Alternative text for the image
- * @param baseDir - Base directory for resolving relative paths
- * @returns Prepared image data ready for embedding
- */
-export async function prepareImageForDocx(imagePath, altText = '', baseDir) {
-    return withErrorContext(async () => {
-        let buffer;
-        let mimeType = 'image/png'; // Default
-        // Handle data URL
-        if (isDataUrl(imagePath)) {
-            const parsed = parseDataUrl(imagePath);
-            if (!parsed) {
-                throw new DocxError('Invalid data URL format', DocxErrorCode.INVALID_IMAGE_DATA_URL, { imagePath: imagePath.substring(0, 50) });
-            }
-            buffer = parsed;
-            // Extract MIME type from data URL
-            const mimeMatch = imagePath.match(/^data:([^;]+);/);
-            if (mimeMatch) {
-                mimeType = mimeMatch[1];
-            }
-        }
-        else {
-            // Handle file path
-            const resolved = resolveImagePath(imagePath, baseDir);
-            // Validate image file
-            const validation = await validateImageFile(resolved);
-            if (!validation.valid) {
-                throw new DocxError(validation.error || 'Invalid image file', DocxErrorCode.INVALID_IMAGE_FILE, { imagePath: resolved });
-            }
-            // Read image file
-            try {
-                buffer = await fs.readFile(resolved);
-            }
-            catch (error) {
-                throw new DocxError(`Failed to read image file: ${error instanceof Error ? error.message : String(error)}`, DocxErrorCode.IMAGE_READ_FAILED, { imagePath: resolved });
-            }
-            // Determine MIME type from file extension
-            const ext = path.extname(resolved).toLowerCase();
-            const mimeTypes = {
-                '.png': 'image/png',
-                '.jpg': 'image/jpeg',
-                '.jpeg': 'image/jpeg',
-                '.gif': 'image/gif',
-                '.bmp': 'image/bmp',
-                '.webp': 'image/webp',
-            };
-            mimeType = mimeTypes[ext] || 'image/png';
-        }
-        return {
-            buffer,
-            altText: altText || path.basename(imagePath),
-            mimeType,
-            // Default dimensions - can be customized
-            width: 600,
-            height: 400,
-        };
-    }, DocxErrorCode.IMAGE_PREPARATION_FAILED, { imagePath });
-}
-/**
- * Create an ImageRun instance for embedding in DOCX paragraphs
- * This is a lower-level utility for direct image insertion
- *
- * @param imageData - Prepared image data
- * @returns ImageRun instance ready to be added to a paragraph
- */
-export function createImageRun(imageData) {
-    try {
-        return new ImageRun({
-            data: imageData.buffer,
-            transformation: {
-                width: imageData.width || 600,
-                height: imageData.height || 400,
-            },
-            altText: {
-                title: imageData.altText,
-                description: imageData.altText,
-            },
-        });
-    }
-    catch (error) {
-        throw new DocxError(`Failed to create image run: ${error instanceof Error ? error.message : String(error)}`, DocxErrorCode.IMAGE_RUN_CREATION_FAILED);
-    }
-}

package/dist/tools/docx/validate.d.ts

@@ -1,33 +0,0 @@
-/**
- * Invariant validation for DOCX write operations.
- *
- * Single Responsibility: capture a structural snapshot of w:body and
- * compare before / after snapshots to guarantee no accidental breakage.
- */
-import type { BodySnapshot } from './types.js';
-export interface ValidationOptions {
-    /**
-     * Expected change in w:body direct child count.
-     * Positive = inserts, negative = deletes.
-     * Default 0 (no structural changes expected).
-     */
-    expectedChildDelta?: number;
-    /**
-     * Expected change in w:tbl count.
-     * Default 0 (no table additions/removals expected).
-     */
-    expectedTableDelta?: number;
-}
-/** Take a snapshot of the body's structural invariants. */
-export declare function captureSnapshot(body: Element): BodySnapshot;
-/**
- * Compare before / after snapshots.
- * Throws a descriptive error if any invariant has been violated,
- * preventing the output file from being written.
- *
- * When `expectedChildDelta` is non-zero (structural ops like insert or
- * delete), signature validation is skipped because the body structure
- * is *expected* to change.  Child count is still validated against
- * the expected delta, and table count must remain unchanged.
- */
-export declare function validateInvariants(before: BodySnapshot, after: BodySnapshot, options?: ValidationOptions): void;

package/dist/tools/docx/validate.js

@@ -1,49 +0,0 @@
-/**
- * Invariant validation for DOCX write operations.
- *
- * Single Responsibility: capture a structural snapshot of w:body and
- * compare before / after snapshots to guarantee no accidental breakage.
- */
-import { getBodyChildren, bodySignature, countTables } from './dom.js';
-// ─── Capture ─────────────────────────────────────────────────────────
-/** Take a snapshot of the body's structural invariants. */
-export function captureSnapshot(body) {
-    const children = getBodyChildren(body);
-    return {
-        bodyChildCount: children.length,
-        tableCount: countTables(children),
-        signature: bodySignature(children),
-    };
-}
-// ─── Validate ────────────────────────────────────────────────────────
-/**
- * Compare before / after snapshots.
- * Throws a descriptive error if any invariant has been violated,
- * preventing the output file from being written.
- *
- * When `expectedChildDelta` is non-zero (structural ops like insert or
- * delete), signature validation is skipped because the body structure
- * is *expected* to change.  Child count is still validated against
- * the expected delta, and table count must remain unchanged.
- */
-export function validateInvariants(before, after, options) {
-    const delta = options?.expectedChildDelta ?? 0;
-    const tableDelta = options?.expectedTableDelta ?? 0;
-    const expectedChildCount = before.bodyChildCount + delta;
-    const expectedTableCount = before.tableCount + tableDelta;
-    const errors = [];
-    if (expectedChildCount !== after.bodyChildCount) {
-        errors.push(`Body child count mismatch: expected ${expectedChildCount} (before ${before.bodyChildCount} + delta ${delta}), got ${after.bodyChildCount}`);
-    }
-    if (expectedTableCount !== after.tableCount) {
-        errors.push(`Table count mismatch: expected ${expectedTableCount} (before ${before.tableCount} + delta ${tableDelta}), got ${after.tableCount}`);
-    }
-    // Only enforce signature stability when no structural ops changed the body
-    if (delta === 0 && before.signature !== after.signature) {
-        errors.push(`Body signature changed:\n  before: ${before.signature}\n  after:  ${after.signature}`);
-    }
-    if (errors.length > 0) {
-        throw new Error('DOCX structural validation failed — output NOT written.\n' +
-            errors.join('\n'));
-    }
-}

package/dist/tools/docx/validators.d.ts

@@ -1,13 +0,0 @@
-/**
- * DOCX Validation Utilities
- *
- * Input validation for paths, operations arrays, and image dimensions.
- *
- * @module docx/validators
- */
-/** Validate that a DOCX file path is a non-empty string ending in `.docx`. */
-export declare function validateDocxPath(path: string): void;
-/** Validate that an operations array is a non-empty array. */
-export declare function validateOperations(operations: unknown[]): void;
-/** Validate optional image width and height (must be positive and finite). */
-export declare function validateImageDimensions(width?: number, height?: number): void;

package/dist/tools/docx/validators.js

@@ -1,40 +0,0 @@
-/**
- * DOCX Validation Utilities
- *
- * Input validation for paths, operations arrays, and image dimensions.
- *
- * @module docx/validators
- */
-import { DocxError, DocxErrorCode } from './errors.js';
-import { isDocxPath } from './utils/paths.js';
-/** Validate that a DOCX file path is a non-empty string ending in `.docx`. */
-export function validateDocxPath(path) {
-    if (!path || typeof path !== 'string') {
-        throw new DocxError('DOCX path must be a non-empty string', DocxErrorCode.INVALID_PATH, { path });
-    }
-    const normalised = path.trim();
-    if (!normalised) {
-        throw new DocxError('DOCX path cannot be empty', DocxErrorCode.INVALID_PATH, { path });
-    }
-    if (!isDocxPath(normalised)) {
-        throw new DocxError('Invalid DOCX path: must end with .docx', DocxErrorCode.INVALID_PATH, { path: normalised });
-    }
-}
-/** Validate that an operations array is a non-empty array. */
-export function validateOperations(operations) {
-    if (!Array.isArray(operations)) {
-        throw new DocxError('Operations must be an array', DocxErrorCode.OPERATION_FAILED, { operations });
-    }
-    if (operations.length === 0) {
-        throw new DocxError('Operations array cannot be empty', DocxErrorCode.OPERATION_FAILED, { operations });
-    }
-}
-/** Validate optional image width and height (must be positive and finite). */
-export function validateImageDimensions(width, height) {
-    if (width !== undefined && (typeof width !== 'number' || width <= 0 || !Number.isFinite(width))) {
-        throw new DocxError('Image width must be a positive finite number', DocxErrorCode.INVALID_IMAGE_FILE, { width });
-    }
-    if (height !== undefined && (typeof height !== 'number' || height <= 0 || !Number.isFinite(height))) {
-        throw new DocxError('Image height must be a positive finite number', DocxErrorCode.INVALID_IMAGE_FILE, { height });
-    }
-}

package/dist/tools/docx/write.d.ts

@@ -1,17 +0,0 @@
-/**
- * writeDocxPatched - the patch-based "update" orchestrator.
- *
- * Single Responsibility: coordinate the full update pipeline:
- *   1. Open DOCX ZIP
- *   2. Parse word/document.xml
- *   3. Snapshot before
- *   4. Apply operations (pass zip for ops that touch auxiliary files)
- *   5. Snapshot after
- *   6. Validate invariants (accounting for structural deltas)
- *   7. Serialize and save
- *
- * Each step delegates to a single-purpose module, keeping this file
- * a pure orchestrator with no direct DOM/XML/ZIP logic.
- */
-import type { DocxOp, WriteDocxResult } from './types.js';
-export declare function writeDocxPatched(inputPath: string, outputPath: string, ops: DocxOp[]): Promise<WriteDocxResult>;

package/dist/tools/docx/write.js

@@ -1,88 +0,0 @@
-/**
- * writeDocxPatched - the patch-based "update" orchestrator.
- *
- * Single Responsibility: coordinate the full update pipeline:
- *   1. Open DOCX ZIP
- *   2. Parse word/document.xml
- *   3. Snapshot before
- *   4. Apply operations (pass zip for ops that touch auxiliary files)
- *   5. Snapshot after
- *   6. Validate invariants (accounting for structural deltas)
- *   7. Serialize and save
- *
- * Each step delegates to a single-purpose module, keeping this file
- * a pure orchestrator with no direct DOM/XML/ZIP logic.
- */
-import { loadDocxZip, getDocumentXml, saveDocxZip } from './zip.js';
-import { parseXml, serializeXml, getBody } from './dom.js';
-import { captureSnapshot, validateInvariants } from './validate.js';
-import { applyOp } from './ops/index.js';
-/** Structural op types that add/remove body children. */
-const STRUCTURAL_INSERT_OPS = new Set([
-    'insert_paragraph_after_text',
-    'insert_table',
-    'insert_image',
-]);
-const STRUCTURAL_DELETE_OPS = new Set(['delete_paragraph_at_body_index']);
-export async function writeDocxPatched(inputPath, outputPath, ops) {
-    // 1. Load ZIP
-    const zip = await loadDocxZip(inputPath);
-    // 2. Parse document.xml
-    const xmlStr = getDocumentXml(zip);
-    const doc = parseXml(xmlStr);
-    const body = getBody(doc);
-    // 3. Before-snapshot
-    const before = captureSnapshot(body);
-    // 4. Apply ops — pass zip for ops that modify auxiliary files
-    const results = [];
-    const warnings = [];
-    for (const op of ops) {
-        try {
-            const result = applyOp(body, op, zip);
-            results.push(result);
-            if (result.status === 'skipped') {
-                warnings.push(`Op ${op.type} skipped: ${result.reason ?? 'unknown'}`);
-            }
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            warnings.push(`Op ${op.type} failed: ${msg}`);
-            results.push({
-                op,
-                status: 'skipped',
-                matched: 0,
-                reason: `error: ${msg}`,
-            });
-        }
-    }
-    // 5. Compute expected structural delta from applied ops
-    let expectedChildDelta = 0;
-    let expectedTableDelta = 0;
-    for (const r of results) {
-        if (r.status !== 'applied')
-            continue;
-        if (STRUCTURAL_INSERT_OPS.has(r.op.type))
-            expectedChildDelta += 1;
-        if (STRUCTURAL_DELETE_OPS.has(r.op.type))
-            expectedChildDelta -= 1;
-        if (r.op.type === 'insert_table')
-            expectedTableDelta += 1;
-    }
-    // 6. After-snapshot
-    const after = captureSnapshot(body);
-    // 7. Validate — throws if structural invariants are broken
-    validateInvariants(before, after, { expectedChildDelta, expectedTableDelta });
-    // 8. Serialize and save (document.xml + any zip-level changes)
-    const newXml = serializeXml(doc);
-    await saveDocxZip(zip, newXml, outputPath);
-    // 9. Build stats
-    const stats = {
-        tablesBefore: before.tableCount,
-        tablesAfter: after.tableCount,
-        bodyChildrenBefore: before.bodyChildCount,
-        bodyChildrenAfter: after.bodyChildCount,
-        bodySignatureBefore: before.signature,
-        bodySignatureAfter: after.signature,
-    };
-    return { outputPath, results, stats, warnings };
-}

package/dist/tools/docx/xml-view-test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tools/docx/xml-view-test.js

@@ -1,63 +0,0 @@
-/**
- * Quick test: extract XML, show context, then edit a checkbox.
- */
-import { extractDocxXml, editDocxXml } from './xml-view.js';
-async function main() {
-    const input = '/Users/eduardsruzga/Downloads/dcox/Wedding Photo Checklist.docx';
-    const output = '/Users/eduardsruzga/Downloads/dcox/Wedding Photo Checklist - XML Edit Test.docx';
-    // 1. Extract and show stats
-    const view = await extractDocxXml(input);
-    console.log(`Extracted XML: ${view.lineCount} lines, ${view.rawSize} raw chars`);
-    // 2. Show context around "Bride hairstyling" with EXACT indentation
-    const lines = view.xml.split('\n');
-    for (let i = 0; i < lines.length; i++) {
-        if (lines[i].includes('Bride hairstyling')) {
-            console.log(`\nFound "Bride hairstyling" at line ${i + 1}:`);
-            for (let j = Math.max(0, i - 20); j <= Math.min(lines.length - 1, i + 5); j++) {
-                console.log(`${String(j + 1).padStart(4)}|${lines[j]}`);
-            }
-            // 3. Build the old/new strings from ACTUAL lines
-            // The ☐ should be around line i-20 to i-15
-            // Find it by scanning backwards
-            let checkboxLine = -1;
-            for (let j = i - 1; j >= Math.max(0, i - 25); j--) {
-                if (lines[j].includes('☐')) {
-                    checkboxLine = j;
-                    break;
-                }
-            }
-            console.log(`\nCheckbox ☐ found at line ${checkboxLine + 1}: "${lines[checkboxLine]}"`);
-            // Use just enough context: the checkbox line + next line to make it unique
-            const oldStr = lines[checkboxLine];
-            const newStr = oldStr.replace('☐', '☑');
-            console.log(`\nold: "${oldStr}"`);
-            console.log(`new: "${newStr}"`);
-            // Check uniqueness
-            const matches = lines.filter(l => l === oldStr).length;
-            console.log(`Exact line matches in document: ${matches}`);
-            if (matches > 1) {
-                // Expand context until we get exactly 1 match
-                for (let ctx = 3; ctx <= 30; ctx++) {
-                    const contextOld = lines.slice(checkboxLine, checkboxLine + ctx).join('\n');
-                    const contextMatches = view.xml.split(contextOld).length - 1;
-                    if (contextMatches === 1) {
-                        console.log(`\nUnique match found with ${ctx}-line context`);
-                        const contextNew = contextOld.replace('☐', '☑');
-                        const result = await editDocxXml(input, output, contextOld, contextNew);
-                        console.log(`Edit result:`, result);
-                        break;
-                    }
-                    else {
-                        console.log(`${ctx} lines of context: ${contextMatches} matches`);
-                    }
-                }
-            }
-            else {
-                const result = await editDocxXml(input, output, oldStr, newStr);
-                console.log(`\nEdit result:`, result);
-            }
-            break;
-        }
-    }
-}
-main().catch(console.error);

package/dist/tools/docx/xml-view.d.ts

@@ -1,56 +0,0 @@
-/**
- * DOCX XML View
- *
- * Exposes word/document.xml from a DOCX file as pretty-printed XML that can be
- * read with offset/length pagination and edited with find/replace, just like a
- * text file. All formatting is preserved because we operate on the actual XML.
- *
- * Round-trip: DOCX → unzip → pretty-print → edit → compact → repack → DOCX
- */
-/**
- * Pretty-print XML by splitting tags onto separate lines with indentation.
- *
- * Preserves content inside text nodes exactly. Self-closing tags, inline
- * open+close tags (e.g. <w:t>text</w:t>), and pure closing tags are all
- * handled so that compact→pretty→compact is lossless.
- */
-export declare function prettyPrintXml(xml: string): string;
-/**
- * Compact pretty-printed XML back to a single line.
- *
- * CRITICAL: Must not introduce or remove whitespace inside <w:t> text nodes
- * or break xml:space="preserve" semantics. We achieve this by only stripping
- * leading indentation (which we added) and joining lines. The original XML
- * had no newlines between tags, so this restores the original form.
- */
-export declare function compactXml(prettyXml: string): string;
-export interface DocxXmlReadResult {
-    /** Pretty-printed XML content */
-    content: string;
-    /** Total number of lines */
-    lineCount: number;
-    /** Source DOCX path */
-    path: string;
-    /** Size of the raw (compact) XML in chars */
-    rawSize: number;
-}
-/**
- * Read the document.xml from a DOCX as pretty-printed, line-based XML.
- * Supports offset/length pagination just like text file reading.
- */
-export declare function readDocxXml(filePath: string, offset?: number, length?: number): Promise<DocxXmlReadResult>;
-/**
- * Apply a find/replace edit to a DOCX file's XML and write a new DOCX.
- *
- * The edit operates on the pretty-printed XML so that line-based context
- * from read_file can be used directly as the search string. After editing,
- * the XML is compacted back and repacked into the DOCX zip.
- *
- * @returns result with status, match count, and output path
- */
-export declare function editDocxXml(inputPath: string, outputPath: string, oldStr: string, newStr: string, expectedReplacements?: number): Promise<{
-    status: 'applied' | 'no_match' | 'unexpected_count';
-    matchCount: number;
-    outputPath: string;
-    message?: string;
-}>;