@wonderwhy-er/desktop-commander 0.2.34 → 0.2.36

package/dist/tools/docx/ops/set-color-for-style.js

@@ -0,0 +1,27 @@
+/**
+ * Op: set_color_for_style
+ *
+ * For every paragraph whose w:pPr/w:pStyle/@w:val === style,
+ * set run-level colour on every w:r in that paragraph.
+ * Does NOT modify word/styles.xml — only in-document run formatting.
+ */
+import { getBodyChildren, getParagraphStyle, ensureRunColor } from '../dom.js';
+export function applySetColorForStyle(body, op) {
+    const children = getBodyChildren(body);
+    let matched = 0;
+    for (const child of children) {
+        if (child.nodeName !== 'w:p')
+            continue;
+        if (getParagraphStyle(child) !== op.style)
+            continue;
+        const runs = child.getElementsByTagName('w:r');
+        for (let i = 0; i < runs.length; i++) {
+            ensureRunColor(runs.item(i), op.color);
+        }
+        matched++;
+    }
+    if (matched === 0) {
+        return { op, status: 'skipped', matched: 0, reason: 'no_match' };
+    }
+    return { op, status: 'applied', matched };
+}

package/dist/tools/docx/ops/set-paragraph-style-at-body-index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Op: set_paragraph_style_at_body_index
+ *
+ * Set (or replace) the paragraph style (w:pPr/w:pStyle) at a given
+ * bodyChildIndex.  Skips if the child is not a w:p.
+ */
+import type { SetParagraphStyleAtBodyIndexOp, OpResult } from '../types.js';
+export declare function applySetParagraphStyleAtBodyIndex(body: Element, op: SetParagraphStyleAtBodyIndexOp): OpResult;

package/dist/tools/docx/ops/set-paragraph-style-at-body-index.js

@@ -0,0 +1,57 @@
+/**
+ * Op: set_paragraph_style_at_body_index
+ *
+ * Set (or replace) the paragraph style (w:pPr/w:pStyle) at a given
+ * bodyChildIndex.  Skips if the child is not a w:p.
+ */
+import { getBodyChildren, nodeListToArray } from '../dom.js';
+export function applySetParagraphStyleAtBodyIndex(body, op) {
+    const children = getBodyChildren(body);
+    const idx = op.bodyChildIndex;
+    if (idx < 0 || idx >= children.length) {
+        return { op, status: 'skipped', matched: 0, reason: 'index_out_of_range' };
+    }
+    const child = children[idx];
+    if (child.nodeName !== 'w:p') {
+        return { op, status: 'skipped', matched: 0, reason: 'not_a_paragraph' };
+    }
+    const doc = child.ownerDocument;
+    if (!doc)
+        return { op, status: 'skipped', matched: 0, reason: 'no_owner_document' };
+    // Find or create w:pPr
+    let pPr = null;
+    for (const n of nodeListToArray(child.childNodes)) {
+        if (n.nodeType === 1 && n.nodeName === 'w:pPr') {
+            pPr = n;
+            break;
+        }
+    }
+    if (!pPr) {
+        pPr = doc.createElement('w:pPr');
+        if (child.firstChild) {
+            child.insertBefore(pPr, child.firstChild);
+        }
+        else {
+            child.appendChild(pPr);
+        }
+    }
+    // Find or create w:pStyle inside pPr
+    let pStyle = null;
+    for (const n of nodeListToArray(pPr.childNodes)) {
+        if (n.nodeType === 1 && n.nodeName === 'w:pStyle') {
+            pStyle = n;
+            break;
+        }
+    }
+    if (!pStyle) {
+        pStyle = doc.createElement('w:pStyle');
+        if (pPr.firstChild) {
+            pPr.insertBefore(pStyle, pPr.firstChild);
+        }
+        else {
+            pPr.appendChild(pStyle);
+        }
+    }
+    pStyle.setAttribute('w:val', op.style);
+    return { op, status: 'applied', matched: 1 };
+}

package/dist/tools/docx/ops/table-set-cell-text.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Op: table_set_cell_text
+ *
+ * Set the text content of a specific table cell.
+ * Targets by: tableIndex (0-based among w:tbl in body), row, col.
+ * Applies minimal text replacement inside the cell's first paragraph.
+ */
+import type { TableSetCellTextOp, OpResult } from '../types.js';
+export declare function applyTableSetCellText(body: Element, op: TableSetCellTextOp): OpResult;

package/dist/tools/docx/ops/table-set-cell-text.js

@@ -0,0 +1,72 @@
+/**
+ * Op: table_set_cell_text
+ *
+ * Set the text content of a specific table cell.
+ * Targets by: tableIndex (0-based among w:tbl in body), row, col.
+ * Applies minimal text replacement inside the cell's first paragraph.
+ */
+import { getBodyChildren, nodeListToArray, setParagraphTextMinimal } from '../dom.js';
+export function applyTableSetCellText(body, op) {
+    const children = getBodyChildren(body);
+    // Find the n-th w:tbl
+    let tableCount = 0;
+    let table = null;
+    for (const child of children) {
+        if (child.nodeName === 'w:tbl') {
+            if (tableCount === op.tableIndex) {
+                table = child;
+                break;
+            }
+            tableCount++;
+        }
+    }
+    if (!table) {
+        return { op, status: 'skipped', matched: 0, reason: 'table_not_found' };
+    }
+    // Find the n-th w:tr
+    const rows = [];
+    for (const child of nodeListToArray(table.childNodes)) {
+        if (child.nodeType === 1 && child.nodeName === 'w:tr') {
+            rows.push(child);
+        }
+    }
+    if (op.row < 0 || op.row >= rows.length) {
+        return { op, status: 'skipped', matched: 0, reason: 'row_out_of_range' };
+    }
+    // Find the n-th w:tc in the row
+    const cells = [];
+    for (const child of nodeListToArray(rows[op.row].childNodes)) {
+        if (child.nodeType === 1 && child.nodeName === 'w:tc') {
+            cells.push(child);
+        }
+    }
+    if (op.col < 0 || op.col >= cells.length) {
+        return { op, status: 'skipped', matched: 0, reason: 'col_out_of_range' };
+    }
+    const cell = cells[op.col];
+    // Find first w:p inside the cell and apply minimal text replacement
+    for (const child of nodeListToArray(cell.childNodes)) {
+        if (child.nodeType === 1 && child.nodeName === 'w:p') {
+            const p = child;
+            const tNodes = p.getElementsByTagName('w:t');
+            if (tNodes.length > 0) {
+                // Existing runs — use minimal replacement
+                setParagraphTextMinimal(p, op.text);
+            }
+            else {
+                // Empty cell — create a run
+                const doc = cell.ownerDocument;
+                if (!doc)
+                    return { op, status: 'skipped', matched: 0, reason: 'no_owner_document' };
+                const r = doc.createElement('w:r');
+                const t = doc.createElement('w:t');
+                t.setAttribute('xml:space', 'preserve');
+                t.textContent = op.text;
+                r.appendChild(t);
+                p.appendChild(r);
+            }
+            return { op, status: 'applied', matched: 1 };
+        }
+    }
+    return { op, status: 'skipped', matched: 0, reason: 'no_paragraph_in_cell' };
+}

package/dist/tools/docx/parsers/image-extractor.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Image Extractor
+ * Utilities for extracting and handling images from DOCX files
+ */
+import type { ZipArchive } from './zip-reader.js';
+import type { DocxRelationship } from '../types.js';
+/**
+ * Get MIME type from file extension or target path
+ */
+export declare function getMimeTypeForTarget(target: string): string;
+/**
+ * Extract all images from a DOCX ZIP archive
+ */
+export declare function extractImagesFromZip(zip: ZipArchive, relMap: Map<string, DocxRelationship>): Map<string, Buffer>;
+/**
+ * Resolve image relationship ID from drawing or pict element
+ */
+export declare function resolveImageRelId(element: Element): string | null;

package/dist/tools/docx/parsers/image-extractor.js

@@ -0,0 +1,61 @@
+/**
+ * Image Extractor
+ * Utilities for extracting and handling images from DOCX files
+ */
+import path from 'path';
+import { readZipFileBuffer } from './zip-reader.js';
+/**
+ * Get MIME type from file extension or target path
+ */
+export function getMimeTypeForTarget(target) {
+    const ext = path.extname(target).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] || 'application/octet-stream';
+}
+/**
+ * Extract all images from a DOCX ZIP archive
+ */
+export function extractImagesFromZip(zip, relMap) {
+    const images = new Map();
+    for (const [relId, rel] of relMap.entries()) {
+        if (!rel.type.includes('/image'))
+            continue;
+        const targetPath = rel.target.startsWith('word/')
+            ? rel.target
+            : `word/${rel.target.replace(/^\/?/, '')}`;
+        const imgBuffer = readZipFileBuffer(zip, targetPath);
+        if (imgBuffer) {
+            images.set(relId, imgBuffer);
+        }
+    }
+    return images;
+}
+/**
+ * Resolve image relationship ID from drawing or pict element
+ */
+export function resolveImageRelId(element) {
+    // Try drawing element first (newer format)
+    const blips = element.getElementsByTagName('a:blip');
+    for (let i = 0; i < blips.length; i++) {
+        const blip = blips[i];
+        const relId = blip.getAttribute('r:embed') || blip.getAttribute('embed');
+        if (relId)
+            return relId;
+    }
+    // Try pict element (older format)
+    const imagedata = element.getElementsByTagName('v:imagedata');
+    for (let i = 0; i < imagedata.length; i++) {
+        const relId = imagedata[i].getAttribute('r:id') || imagedata[i].getAttribute('id');
+        if (relId)
+            return relId;
+    }
+    return null;
+}

package/dist/tools/docx/parsers/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * DOCX Parsers
+ * Centralized exports for all parsing utilities
+ */
+export * from './zip-reader.js';
+export * from './xml-parser.js';
+export * from './image-extractor.js';
+export * from './paragraph-parser.js';
+export * from './table-parser.js';

package/dist/tools/docx/parsers/index.js

@@ -0,0 +1,9 @@
+/**
+ * DOCX Parsers
+ * Centralized exports for all parsing utilities
+ */
+export * from './zip-reader.js';
+export * from './xml-parser.js';
+export * from './image-extractor.js';
+export * from './paragraph-parser.js';
+export * from './table-parser.js';

package/dist/tools/docx/parsers/paragraph-parser.d.ts

@@ -0,0 +1,2 @@
+import type { DocxParagraph } from '../types.js';
+export declare function parseParagraphElement(paragraph: Element, images: Map<string, Buffer>, headingLevel: number | null): DocxParagraph | null;

package/dist/tools/docx/parsers/paragraph-parser.js

@@ -0,0 +1,88 @@
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+// @ts-ignore
+import * as docx from 'docx';
+const { Paragraph, TextRun, ImageRun, HeadingLevel } = docx;
+import { getElementChildren } from './xml-parser.js';
+import { resolveImageRelId } from './image-extractor.js';
+export function parseParagraphElement(paragraph, images, headingLevel) {
+    const runs = extractRunsFromParagraph(paragraph, images);
+    if (runs.length === 0) {
+        return null;
+    }
+    return new Paragraph({
+        children: runs,
+        heading: headingLevel ? getDocxHeadingLevel(headingLevel) : undefined,
+    });
+}
+function extractRunsFromParagraph(paragraph, images) {
+    const runs = [];
+    const children = getElementChildren(paragraph);
+    for (const child of children) {
+        const nodeName = child.nodeName;
+        if (nodeName === 'w:r') {
+            const textRuns = extractTextRun(child, images);
+            runs.push(...textRuns);
+        }
+        else if (nodeName === 'w:hyperlink') {
+            const linkRuns = child.getElementsByTagName('w:r');
+            for (let i = 0; i < linkRuns.length; i++) {
+                const textRuns = extractTextRun(linkRuns[i], images);
+                runs.push(...textRuns);
+            }
+        }
+    }
+    return runs;
+}
+function extractTextRun(run, images) {
+    const runs = [];
+    const rPr = run.getElementsByTagName('w:rPr')[0];
+    const isBold = rPr?.getElementsByTagName('w:b').length > 0;
+    const isItalic = rPr?.getElementsByTagName('w:i').length > 0;
+    const children = getElementChildren(run);
+    for (const child of children) {
+        const nodeName = child.nodeName;
+        if (nodeName === 'w:t') {
+            const text = child.textContent || '';
+            if (text) {
+                runs.push(new TextRun({
+                    text,
+                    bold: isBold,
+                    italics: isItalic,
+                }));
+            }
+        }
+        else if (nodeName === 'w:tab') {
+            runs.push(new TextRun({ text: '\t' }));
+        }
+        else if (nodeName === 'w:br') {
+            runs.push(new TextRun({ text: '\n', break: 1 }));
+        }
+        else if (nodeName === 'w:drawing' || nodeName === 'w:pict') {
+            const relId = resolveImageRelId(child);
+            if (relId && images.has(relId)) {
+                try {
+                    runs.push(new ImageRun({
+                        data: images.get(relId),
+                        transformation: { width: 600, height: 400 },
+                    }));
+                }
+                catch (err) {
+                    // Skip invalid images
+                }
+            }
+        }
+    }
+    return runs;
+}
+function getDocxHeadingLevel(level) {
+    const levelMap = {
+        1: HeadingLevel.HEADING_1,
+        2: HeadingLevel.HEADING_2,
+        3: HeadingLevel.HEADING_3,
+        4: HeadingLevel.HEADING_4,
+        5: HeadingLevel.HEADING_5,
+        6: HeadingLevel.HEADING_6,
+    };
+    return levelMap[level] ?? HeadingLevel.HEADING_1;
+}

package/dist/tools/docx/parsers/table-parser.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Table Parser
+ * Parses DOCX table elements to DOCX library Table objects
+ */
+import type { DocxTable } from '../types.js';
+/**
+ * Parse a table element to DOCX Table
+ */
+export declare function parseTableElement(table: Element, images: Map<string, Buffer>): DocxTable | null;

package/dist/tools/docx/parsers/table-parser.js

@@ -0,0 +1,72 @@
+/**
+ * Table Parser
+ * Parses DOCX table elements to DOCX library Table objects
+ */
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+// @ts-ignore
+import * as docx from 'docx';
+const { Table, TableRow, TableCell, Paragraph, WidthType } = docx;
+import { parseParagraphElement } from './paragraph-parser.js';
+/**
+ * Parse a table element to DOCX Table
+ */
+export function parseTableElement(table, images) {
+    const rows = [];
+    const rowNodes = table.getElementsByTagName('w:tr');
+    for (let i = 0; i < rowNodes.length; i++) {
+        const rowNode = rowNodes[i];
+        const row = parseTableRow(rowNode, images);
+        if (row) {
+            rows.push(row);
+        }
+    }
+    if (rows.length === 0) {
+        return null;
+    }
+    return new Table({
+        width: { size: 100, type: WidthType.PERCENTAGE },
+        rows,
+    });
+}
+/**
+ * Parse a table row element
+ */
+function parseTableRow(rowNode, images) {
+    const cells = [];
+    const cellNodes = rowNode.getElementsByTagName('w:tc');
+    for (let j = 0; j < cellNodes.length; j++) {
+        const cellNode = cellNodes[j];
+        const cell = parseTableCell(cellNode, images);
+        if (cell) {
+            cells.push(cell);
+        }
+    }
+    if (cells.length === 0) {
+        return null;
+    }
+    return new TableRow({
+        children: cells,
+    });
+}
+/**
+ * Parse a table cell element
+ */
+function parseTableCell(cellNode, images) {
+    const cellParagraphs = [];
+    const paragraphNodes = cellNode.getElementsByTagName('w:p');
+    for (let k = 0; k < paragraphNodes.length; k++) {
+        const paraNode = paragraphNodes[k];
+        const para = parseParagraphElement(paraNode, images, null);
+        if (para) {
+            cellParagraphs.push(para);
+        }
+    }
+    // Ensure at least one paragraph per cell
+    if (cellParagraphs.length === 0) {
+        cellParagraphs.push(new Paragraph({ text: '' }));
+    }
+    return new TableCell({
+        children: cellParagraphs,
+    });
+}

package/dist/tools/docx/parsers/xml-parser.d.ts

@@ -0,0 +1,25 @@
+/**
+ * XML Parser Utilities
+ * Helper functions for parsing DOCX XML content
+ */
+import type { DocxRelationship } from '../types.js';
+/**
+ * Get all element children of a node
+ */
+export declare function getElementChildren(node: Node): Element[];
+/**
+ * Get attribute value, checking both direct and namespaced attributes
+ */
+export declare function getAttributeValue(node: Element, name: string): string | null;
+/**
+ * Parse XML string to Document
+ */
+export declare function parseXml(xml: string): Document;
+/**
+ * Extract relationship map from relationships XML
+ */
+export declare function extractRelationshipMap(relsXml: string | null): Map<string, DocxRelationship>;
+/**
+ * Get heading level from paragraph element
+ */
+export declare function getHeadingLevelFromParagraph(paragraph: Element): number | null;

package/dist/tools/docx/parsers/xml-parser.js

@@ -0,0 +1,71 @@
+/**
+ * XML Parser Utilities
+ * Helper functions for parsing DOCX XML content
+ */
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const { DOMParser } = require('@xmldom/xmldom');
+/**
+ * Get all element children of a node
+ */
+export function getElementChildren(node) {
+    const children = [];
+    for (let i = 0; i < node.childNodes.length; i++) {
+        const child = node.childNodes[i];
+        if (child.nodeType === 1) { // ELEMENT_NODE
+            children.push(child);
+        }
+    }
+    return children;
+}
+/**
+ * Get attribute value, checking both direct and namespaced attributes
+ */
+export function getAttributeValue(node, name) {
+    return node.getAttribute(name) || node.getAttribute(`w:${name}`) || null;
+}
+/**
+ * Parse XML string to Document
+ */
+export function parseXml(xml) {
+    const parser = new DOMParser();
+    return parser.parseFromString(xml, 'application/xml');
+}
+/**
+ * Extract relationship map from relationships XML
+ */
+export function extractRelationshipMap(relsXml) {
+    const relMap = new Map();
+    if (!relsXml)
+        return relMap;
+    const relDoc = parseXml(relsXml);
+    const rels = relDoc.getElementsByTagName('Relationship');
+    for (let i = 0; i < rels.length; i++) {
+        const rel = rels[i];
+        const id = rel.getAttribute('Id');
+        const type = rel.getAttribute('Type') || '';
+        const target = rel.getAttribute('Target') || '';
+        if (id && target) {
+            relMap.set(id, { target, type });
+        }
+    }
+    return relMap;
+}
+/**
+ * Get heading level from paragraph element
+ */
+export function getHeadingLevelFromParagraph(paragraph) {
+    const pPr = paragraph.getElementsByTagName('w:pPr')[0];
+    if (!pPr)
+        return null;
+    const pStyle = pPr.getElementsByTagName('w:pStyle')[0];
+    if (!pStyle)
+        return null;
+    const styleVal = getAttributeValue(pStyle, 'val');
+    if (!styleVal)
+        return null;
+    const match = styleVal.match(/heading\s*([1-6])/i);
+    if (!match)
+        return null;
+    return Number(match[1]);
+}

package/dist/tools/docx/parsers/zip-reader.d.ts

@@ -0,0 +1,23 @@
+/**
+ * ZIP File Reader
+ * Utilities for reading files from DOCX ZIP archives
+ */
+declare const PizZip: any;
+export type ZipArchive = InstanceType<typeof PizZip>;
+/**
+ * Create a ZIP archive from a buffer
+ */
+export declare function createZipFromBuffer(buffer: Buffer): ZipArchive;
+/**
+ * Read a text file from a ZIP archive
+ */
+export declare function readZipFileText(zip: ZipArchive, filePath: string): string | null;
+/**
+ * Read a binary file from a ZIP archive as Buffer
+ */
+export declare function readZipFileBuffer(zip: ZipArchive, filePath: string): Buffer | null;
+/**
+ * Check if a file exists in the ZIP archive
+ */
+export declare function zipFileExists(zip: ZipArchive, filePath: string): boolean;
+export {};

package/dist/tools/docx/parsers/zip-reader.js

@@ -0,0 +1,52 @@
+/**
+ * ZIP File Reader
+ * Utilities for reading files from DOCX ZIP archives
+ */
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const PizZip = require('pizzip');
+/**
+ * Create a ZIP archive from a buffer
+ */
+export function createZipFromBuffer(buffer) {
+    return new PizZip(buffer);
+}
+/**
+ * Read a text file from a ZIP archive
+ */
+export function readZipFileText(zip, filePath) {
+    const file = zip.file(filePath);
+    if (!file)
+        return null;
+    if (typeof file.asText === 'function') {
+        return file.asText();
+    }
+    if (typeof file.asBinary === 'function') {
+        return Buffer.from(file.asBinary(), 'binary').toString('utf8');
+    }
+    return null;
+}
+/**
+ * Read a binary file from a ZIP archive as Buffer
+ */
+export function readZipFileBuffer(zip, filePath) {
+    const file = zip.file(filePath);
+    if (!file)
+        return null;
+    if (typeof file.asUint8Array === 'function') {
+        return Buffer.from(file.asUint8Array());
+    }
+    if (typeof file.asNodeBuffer === 'function') {
+        return file.asNodeBuffer();
+    }
+    if (typeof file.asBinary === 'function') {
+        return Buffer.from(file.asBinary(), 'binary');
+    }
+    return null;
+}
+/**
+ * Check if a file exists in the ZIP archive
+ */
+export function zipFileExists(zip, filePath) {
+    return zip.file(filePath) !== null;
+}

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

@@ -0,0 +1,27 @@
+/**
+ * DOCX reading utilities
+ * Extracts text, metadata, and compact outlines from DOCX files.
+ */
+import type { DocxMetadata, DocxParagraph, ReadDocxResult } from './types.js';
+/**
+ * Return a token-efficient outline of a DOCX file.
+ * Every paragraph gets a bodyChildIndex (among ALL w:body children)
+ * plus a paragraphIndex (counting only w:p), style id, and text.
+ */
+export declare function readDocxOutline(filePath: string): Promise<ReadDocxResult>;
+/** Extract plain text from DOCX. */
+export declare function extractTextFromDocx(path: string): Promise<string>;
+/** Get comprehensive metadata. */
+export declare function getDocxMetadata(path: string): Promise<DocxMetadata>;
+/** Extract body XML. */
+export declare function extractBodyXml(path: string): Promise<string>;
+/** Read DOCX file with optional pagination. */
+export declare function readDocx(path: string, options?: {
+    offset?: number;
+    length?: number;
+}): Promise<{
+    text: string;
+    paragraphs: DocxParagraph[];
+    metadata: DocxMetadata;
+    bodyXml: string;
+}>;