@wonderwhy-er/desktop-commander 0.2.36 → 0.2.38

package/dist/tools/docx/dom.js

@@ -54,6 +54,46 @@ export function getBodyChildren(body) {
     }
     return out;
 }
+/**
+ * Return ALL top‑level tables that are logically in the body, including those
+ * wrapped in structured document tags (w:sdt / w:sdtContent).
+ *
+ * Previous logic only saw tables that were direct children of <w:body>. That
+ * meant tables inside SDTs were invisible to table operations and readDocxOutline.
+ * This helper walks the body tree and collects any <w:tbl> that appears as a
+ * *first‑class* block (we do not recurse into tables themselves, so nested
+ * tables are not double‑counted).
+ */
+export function getAllBodyTables(body) {
+    const result = [];
+    function collectFromNode(node) {
+        const name = node.nodeName;
+        if (name === 'w:tbl') {
+            result.push(node);
+            return; // don't recurse into tables to avoid nested counting
+        }
+        // If this is a structured document tag, look into its content container.
+        if (name === 'w:sdt') {
+            const sdtContent = findDirectChild(node, 'w:sdtContent');
+            if (sdtContent) {
+                for (const child of nodeListToArray(sdtContent.childNodes)) {
+                    if (child.nodeType === 1)
+                        collectFromNode(child);
+                }
+            }
+            return;
+        }
+        // Generic container: recurse into element children.
+        for (const child of nodeListToArray(node.childNodes)) {
+            if (child.nodeType === 1)
+                collectFromNode(child);
+        }
+    }
+    for (const child of getBodyChildren(body)) {
+        collectFromNode(child);
+    }
+    return result;
+}
 // ═══════════════════════════════════════════════════════════════════════
 // Body signature
 // ═══════════════════════════════════════════════════════════════════════
@@ -100,13 +140,108 @@ export function getParagraphStyle(p) {
     return null;
 }
 // ═══════════════════════════════════════════════════════════════════════
+// Table content extraction
+// ═══════════════════════════════════════════════════════════════════════
+/**
+ * Extract all text content from a table cell (w:tc).
+ * Returns the concatenated text from all paragraphs in the cell.
+ */
+export function getCellText(tc) {
+    const paragraphs = tc.getElementsByTagName('w:p');
+    const texts = [];
+    for (let i = 0; i < paragraphs.length; i++) {
+        const p = paragraphs.item(i);
+        if (p) {
+            const text = getParagraphText(p).trim();
+            if (text)
+                texts.push(text);
+        }
+    }
+    return texts.join(' '); // Join multiple paragraphs in cell with space
+}
+/**
+ * Extract all rows from a table (w:tbl).
+ * Returns an array of rows, where each row is an array of cell text strings.
+ * First row is treated as header if it exists.
+ */
+export function getTableContent(tbl) {
+    const rows = [];
+    for (const child of nodeListToArray(tbl.childNodes)) {
+        if (child.nodeType === 1 && child.nodeName === 'w:tr') {
+            rows.push(child);
+        }
+    }
+    if (rows.length === 0) {
+        return { rows: [] };
+    }
+    // Extract cells from each row
+    const tableRows = [];
+    for (const row of rows) {
+        const cells = [];
+        for (const child of nodeListToArray(row.childNodes)) {
+            if (child.nodeType === 1 && child.nodeName === 'w:tc') {
+                cells.push(getCellText(child));
+            }
+        }
+        if (cells.length > 0) {
+            tableRows.push(cells);
+        }
+    }
+    // First row might be header - check if it has bold formatting
+    // For simplicity, we'll treat first row as potential header
+    // User can determine this based on style or content
+    if (tableRows.length > 0) {
+        const firstRow = tableRows[0];
+        const restRows = tableRows.slice(1);
+        return {
+            headers: firstRow.length > 0 ? firstRow : undefined,
+            rows: restRows.length > 0 ? restRows : [],
+        };
+    }
+    return { rows: tableRows };
+}
+/**
+ * Get table style from w:tblPr/w:tblStyle/@w:val, or null if absent.
+ */
+export function getTableStyle(tbl) {
+    const tblPr = tbl.getElementsByTagName('w:tblPr').item(0);
+    if (!tblPr)
+        return null;
+    const tblStyle = tblPr.getElementsByTagName('w:tblStyle').item(0);
+    if (!tblStyle)
+        return null;
+    return tblStyle.getAttribute('w:val');
+}
+// ═══════════════════════════════════════════════════════════════════════
+// Image reference extraction
+// ═══════════════════════════════════════════════════════════════════════
+/**
+ * Extract image reference from a w:drawing element.
+ * Returns the relationship ID (rId) and media file path if found.
+ */
+export function getImageReference(drawing) {
+    // Find a:blip/@r:embed to get the relationship ID
+    const blip = drawing.getElementsByTagName('a:blip').item(0);
+    if (!blip)
+        return { rId: null, mediaPath: null };
+    const rId = blip.getAttribute('r:embed');
+    if (!rId)
+        return { rId: null, mediaPath: null };
+    // Media path will be resolved from relationships file
+    // For now, return the rId - the caller will resolve it from rels
+    return { rId, mediaPath: null };
+}
+// ═══════════════════════════════════════════════════════════════════════
 // Minimal text replacement
 // ═══════════════════════════════════════════════════════════════════════
 /**
  * Replace the text of a paragraph with minimal DOM changes.
  * Sets the FIRST w:t to `text`, clears every subsequent w:t.
  * Sets xml:space="preserve" so leading/trailing spaces survive.
- * Does NOT recreate runs or remove paragraph properties.
+ * Does NOT remove/recreate runs or remove paragraph properties.
+ *
+ * WARNING: This function does NOT preserve multiple runs with different styles.
+ * Use setParagraphTextPreservingStyles() for cells with multiple styled runs.
  */
 export function setParagraphTextMinimal(p, text) {
     const tNodes = p.getElementsByTagName('w:t');
@@ -119,6 +254,91 @@ export function setParagraphTextMinimal(p, text) {
         tNodes.item(i).textContent = '';
     }
 }
+/**
+ * Replace paragraph text while preserving all run styles.
+ *
+ * This function preserves the structure of all runs (w:r) and their
+ * properties (w:rPr), distributing the new text across existing runs.
+ *
+ * Strategy:
+ * 1. Collect all runs with their properties
+ * 2. Distribute new text across runs (preserving run count and styles)
+ * 3. If new text is longer, extend the last run
+ * 4. If new text is shorter, clear excess runs but keep their structure
+ */
+export function setParagraphTextPreservingStyles(p, text) {
+    const doc = p.ownerDocument;
+    if (!doc)
+        return;
+    // Work on ALL <w:t> descendants, not just direct children.
+    // This covers runs inside hyperlinks, smart tags, etc.
+    const tNodes = p.getElementsByTagName('w:t');
+    if (tNodes.length === 0) {
+        // No text nodes exist - create a minimal run + text.
+        const r = doc.createElement('w:r');
+        const t = doc.createElement('w:t');
+        t.setAttribute('xml:space', 'preserve');
+        t.textContent = text;
+        r.appendChild(t);
+        p.appendChild(r);
+        return;
+    }
+    // First text node gets the NEW text.
+    const first = tNodes.item(0);
+    first.textContent = text;
+    first.setAttribute('xml:space', 'preserve');
+    // All other text nodes are cleared, but their runs (and w:rPr) remain,
+    // so formatting structures are preserved while old text disappears.
+    for (let i = 1; i < tNodes.length; i++) {
+        const t = tNodes.item(i);
+        if (t)
+            t.textContent = '';
+    }
+}
+/**
+ * Replace cell text while preserving ALL paragraphs and their styles.
+ *
+ * This function works at the cell level:
+ * - Preserves ALL paragraphs in the cell (doesn't remove any)
+ * - Updates text in the first paragraph while preserving its styles
+ * - Keeps all other paragraphs intact with their original text and styles
+ *
+ * This ensures that cells with multiple paragraphs (each with different
+ * styles, font sizes, etc.) maintain their structure after text replacement.
+ *
+ * Example: If a cell has:
+ *   - Paragraph 1: "LAWN AND LANDSCAPE" (Heading1 style, large font, red color)
+ *   - Paragraph 2: "Take your weekends back..." (Normal style, smaller font, black color)
+ *
+ * Replacing with "EARTH AND MOUNTAIN" will:
+ *   - Update paragraph 1 to "EARTH AND MOUNTAIN" (preserving Heading1 style, large font, red color)
+ *   - Keep paragraph 2 completely intact with its original text and style
+ */
+export function setCellTextPreservingStyles(tc, text) {
+    // Convert NodeList to array to avoid live NodeList issues
+    const paragraphs = nodeListToArray(tc.getElementsByTagName('w:p'));
+    if (paragraphs.length === 0) {
+        // Cell has no paragraphs - create one
+        const doc = tc.ownerDocument;
+        if (!doc)
+            return;
+        const p = doc.createElement('w:p');
+        const r = doc.createElement('w:r');
+        const t = doc.createElement('w:t');
+        t.setAttribute('xml:space', 'preserve');
+        t.textContent = text;
+        r.appendChild(t);
+        p.appendChild(r);
+        tc.appendChild(p);
+        return;
+    }
+    // Update first paragraph with new text, preserving all its styles
+    // This function preserves all runs and their properties (colors, bold, italic, etc.)
+    setParagraphTextPreservingStyles(paragraphs[0], text);
+    // CRITICAL: All other paragraphs remain completely untouched
+    // They keep their original text, styles, runs, and all formatting
+    // This ensures multi-paragraph cells maintain their full structure
+}
 // ═══════════════════════════════════════════════════════════════════════
 // Run-level formatting helpers
 // ═══════════════════════════════════════════════════════════════════════

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

@@ -4,7 +4,7 @@
 export { readDocxOutline } from './read.js';
 export { writeDocxPatched } from './write.js';
 export { createDocxNew } from './create.js';
-export type { DocxContentStructure, DocxContentItem, DocxContentParagraph, DocxContentTable, DocxContentImage, } from './types.js';
+export type { DocxContentStructure, DocxContentItem, DocxContentParagraph, DocxContentTable, DocxContentImage, DocxTableCellContent, } from './types.js';
 export { readDocx, extractTextFromDocx, getDocxMetadata, extractBodyXml } from './read.js';
 export { writeDocx, modifyDocxContent, replaceBodyXml } from './modify.js';
-export type { DocxMetadata, DocxParagraph, DocxRun, DocxModification, ParagraphOutline, ReadDocxResult, WriteDocxStats, WriteDocxResult, BodySnapshot, DocxOp, OpResult, } from './types.js';
+export type { DocxMetadata, DocxParagraph, DocxRun, DocxModification, ParagraphOutline, TableOutline, ImageOutline, ReadDocxResult, WriteDocxStats, WriteDocxResult, BodySnapshot, DocxOp, OpResult, } from './types.js';

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

@@ -12,6 +12,7 @@ import { applySetParagraphStyleAtBodyIndex } from './set-paragraph-style-at-body
 import { applyInsertParagraphAfterText } from './insert-paragraph-after-text.js';
 import { applyDeleteParagraphAtBodyIndex } from './delete-paragraph-at-body-index.js';
 import { applyTableSetCellText } from './table-set-cell-text.js';
+import { applyReplaceTableCellText } from './replace-table-cell-text.js';
 import { applyReplaceHyperlinkUrl } from './replace-hyperlink-url.js';
 import { applyHeaderReplaceTextExact } from './header-replace-text-exact.js';
 import { applyInsertTable } from './insert-table-after-text.js';
@@ -42,6 +43,8 @@ export function applyOp(body, op, zip) {
             return applyDeleteParagraphAtBodyIndex(body, op);
         case 'table_set_cell_text':
             return applyTableSetCellText(body, op);
+        case 'replace_table_cell_text':
+            return applyReplaceTableCellText(body, op);
         case 'replace_hyperlink_url':
             if (!zip)
                 return { op, status: 'skipped', matched: 0, reason: 'zip_required_for_hyperlink_op' };

package/dist/tools/docx/ops/replace-paragraph-text-exact.d.ts

@@ -1,9 +1,21 @@
 /**
  * Op: replace_paragraph_text_exact
  *
- * Find FIRST paragraph whose trimmed text === `from`.
- * Replace only the first w:t with `to`; clear other w:t nodes.
- * Does NOT remove/recreate runs or paragraph properties.
+ * Find FIRST paragraph whose trimmed text === `from` **anywhere in the body**,
+ * including paragraphs inside table cells, content controls, etc.
+ *
+ * Replacement behavior:
+ * - Replaces the matched paragraph's text while preserving all its run styles
+ * - Preserves all other paragraphs in the same cell (if the paragraph is in a table cell)
+ * - Preserves paragraph properties (w:pPr) and run properties (w:rPr)
+ *
+ * This is useful when you want to replace a specific paragraph by its exact text,
+ * especially in table cells where you want to replace one paragraph while keeping
+ * others intact. For example, replacing "LAWN AND LANDSCAPE" with "EARTH AND MOUNTAIN"
+ * in a cell that also contains a subtitle paragraph will preserve the subtitle.
+ *
+ * Note: For replacing entire cell content (matching by full cell text), use
+ * `replace_table_cell_text` instead.
  */
 import type { ReplaceParagraphTextExactOp, OpResult } from '../types.js';
 export declare function applyReplaceParagraphTextExact(body: Element, op: ReplaceParagraphTextExactOp): OpResult;

package/dist/tools/docx/ops/replace-paragraph-text-exact.js

@@ -1,19 +1,34 @@
 /**
  * Op: replace_paragraph_text_exact
  *
- * Find FIRST paragraph whose trimmed text === `from`.
- * Replace only the first w:t with `to`; clear other w:t nodes.
- * Does NOT remove/recreate runs or paragraph properties.
+ * Find FIRST paragraph whose trimmed text === `from` **anywhere in the body**,
+ * including paragraphs inside table cells, content controls, etc.
+ *
+ * Replacement behavior:
+ * - Replaces the matched paragraph's text while preserving all its run styles
+ * - Preserves all other paragraphs in the same cell (if the paragraph is in a table cell)
+ * - Preserves paragraph properties (w:pPr) and run properties (w:rPr)
+ *
+ * This is useful when you want to replace a specific paragraph by its exact text,
+ * especially in table cells where you want to replace one paragraph while keeping
+ * others intact. For example, replacing "LAWN AND LANDSCAPE" with "EARTH AND MOUNTAIN"
+ * in a cell that also contains a subtitle paragraph will preserve the subtitle.
+ *
+ * Note: For replacing entire cell content (matching by full cell text), use
+ * `replace_table_cell_text` instead.
  */
-import { getBodyChildren, getParagraphText, setParagraphTextMinimal } from '../dom.js';
+import { getParagraphText, setParagraphTextPreservingStyles } from '../dom.js';
 export function applyReplaceParagraphTextExact(body, op) {
-    const children = getBodyChildren(body);
     const target = op.from.trim();
-    for (const child of children) {
-        if (child.nodeName !== 'w:p')
-            continue;
-        if (getParagraphText(child).trim() === target) {
-            setParagraphTextMinimal(child, op.to);
+    // Traverse **all** paragraphs in the body, not just direct body children.
+    // This includes paragraphs inside table cells, content controls, etc.
+    const paragraphs = body.getElementsByTagName('w:p');
+    for (let i = 0; i < paragraphs.length; i++) {
+        const p = paragraphs.item(i);
+        const paragraphText = getParagraphText(p).trim();
+        if (paragraphText === target) {
+            // Preserve all run styles (colors, bold, italic, etc.) when replacing
+            setParagraphTextPreservingStyles(p, op.to);
             return { op, status: 'applied', matched: 1 };
         }
     }

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

@@ -0,0 +1,25 @@
+/**
+ * Op: replace_table_cell_text
+ *
+ * Goal: Replace the "logical value" of a cell while preserving layout and styles.
+ *
+ * Matching strategy (tried in order):
+ * 1. Match by full cell text (all paragraphs joined with spaces)
+ * 2. Match by first paragraph text only
+ *
+ * When the caller passes FULL cell text in `from` / `to` (common for LLMs), we
+ * interpret the change like this:
+ *
+ *   from: "<OLD_TITLE> <SUBTITLE ...>"
+ *   to:   "<NEW_TITLE> <SUBTITLE ...>"
+ *
+ * i.e. only the *title* (first paragraph) changed, the rest of the cell content
+ * stayed the same. We detect the unchanged suffix and compute NEW_TITLE by
+ * stripping that suffix from `to`. Then we only change the first paragraph text,
+ * keeping all other paragraphs (subtitle, etc.) exactly as they were.
+ *
+ * If we cannot safely detect that pattern, we fall back to treating `from`/`to`
+ * as simple first‑paragraph values.
+ */
+import type { ReplaceTableCellTextOp, OpResult } from '../types.js';
+export declare function applyReplaceTableCellText(body: Element, op: ReplaceTableCellTextOp): OpResult;

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

@@ -0,0 +1,85 @@
+/**
+ * Op: replace_table_cell_text
+ *
+ * Goal: Replace the "logical value" of a cell while preserving layout and styles.
+ *
+ * Matching strategy (tried in order):
+ * 1. Match by full cell text (all paragraphs joined with spaces)
+ * 2. Match by first paragraph text only
+ *
+ * When the caller passes FULL cell text in `from` / `to` (common for LLMs), we
+ * interpret the change like this:
+ *
+ *   from: "<OLD_TITLE> <SUBTITLE ...>"
+ *   to:   "<NEW_TITLE> <SUBTITLE ...>"
+ *
+ * i.e. only the *title* (first paragraph) changed, the rest of the cell content
+ * stayed the same. We detect the unchanged suffix and compute NEW_TITLE by
+ * stripping that suffix from `to`. Then we only change the first paragraph text,
+ * keeping all other paragraphs (subtitle, etc.) exactly as they were.
+ *
+ * If we cannot safely detect that pattern, we fall back to treating `from`/`to`
+ * as simple first‑paragraph values.
+ */
+import { getAllBodyTables, nodeListToArray, getCellText, getParagraphText, setCellTextPreservingStyles } from '../dom.js';
+export function applyReplaceTableCellText(body, op) {
+    const target = op.from.trim();
+    // Find all logical tables in the body, including those inside SDTs.
+    const tables = getAllBodyTables(body);
+    // Search through all tables
+    for (const table of tables) {
+        // Get all rows
+        const rows = [];
+        for (const child of nodeListToArray(table.childNodes)) {
+            if (child.nodeType === 1 && child.nodeName === 'w:tr') {
+                rows.push(child);
+            }
+        }
+        // Search through all cells in all rows
+        for (const row of rows) {
+            const cells = [];
+            for (const child of nodeListToArray(row.childNodes)) {
+                if (child.nodeType === 1 && child.nodeName === 'w:tc') {
+                    cells.push(child);
+                }
+            }
+            for (const cell of cells) {
+                const cellText = getCellText(cell).trim();
+                // Strategy 1: full cell text match — try to detect a "title-only" change
+                if (cellText === target) {
+                    const paragraphs = cell.getElementsByTagName('w:p');
+                    if (paragraphs.length > 0) {
+                        const firstP = paragraphs.item(0);
+                        const firstPText = getParagraphText(firstP).trim();
+                        // Cell's "suffix" is everything after the first paragraph text
+                        const suffixFrom = cellText.slice(firstPText.length).trimStart();
+                        const toTrimmed = op.to.trim();
+                        let newFirstText = toTrimmed;
+                        if (suffixFrom.length > 0 && toTrimmed.endsWith(suffixFrom)) {
+                            // Common LLM pattern:
+                            //   from: "<OLD_TITLE> <SUFFIX>"
+                            //   to:   "<NEW_TITLE> <SUFFIX>"
+                            // Extract "<NEW_TITLE>" by removing the unchanged suffix.
+                            newFirstText = toTrimmed
+                                .slice(0, toTrimmed.length - suffixFrom.length)
+                                .trimEnd();
+                        }
+                        setCellTextPreservingStyles(cell, newFirstText);
+                        return { op, status: 'applied', matched: 1 };
+                    }
+                }
+                // Strategy 2: match by first paragraph text only
+                const paragraphs = cell.getElementsByTagName('w:p');
+                if (paragraphs.length > 0) {
+                    const firstP = paragraphs.item(0);
+                    const firstParagraphText = getParagraphText(firstP).trim();
+                    if (firstParagraphText === target) {
+                        setCellTextPreservingStyles(cell, op.to);
+                        return { op, status: 'applied', matched: 1 };
+                    }
+                }
+            }
+        }
+    }
+    return { op, status: 'skipped', matched: 0, reason: 'no_match' };
+}

package/dist/tools/docx/ops/set-color-for-paragraph-exact.d.ts

@@ -1,7 +1,8 @@
 /**
  * Op: set_color_for_paragraph_exact
  *
- * Find FIRST paragraph whose trimmed text === `text`.
+ * Find FIRST paragraph whose trimmed text === `text` **anywhere in the body**,
+ * including paragraphs inside tables and other containers.
  * Apply run-level colour to every w:r in that paragraph.
  */
 import type { SetColorForParagraphExactOp, OpResult } from '../types.js';

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

@@ -1,19 +1,20 @@
 /**
  * Op: set_color_for_paragraph_exact
  *
- * Find FIRST paragraph whose trimmed text === `text`.
+ * Find FIRST paragraph whose trimmed text === `text` **anywhere in the body**,
+ * including paragraphs inside tables and other containers.
  * Apply run-level colour to every w:r in that paragraph.
  */
-import { getBodyChildren, getParagraphText, ensureRunColor } from '../dom.js';
+import { getParagraphText, ensureRunColor } from '../dom.js';
 export function applySetColorForParagraphExact(body, op) {
-    const children = getBodyChildren(body);
     const target = op.text.trim();
-    for (const child of children) {
-        if (child.nodeName !== 'w:p')
+    // Traverse **all** paragraphs in the body, not just direct children.
+    const paragraphs = body.getElementsByTagName('w:p');
+    for (let i = 0; i < paragraphs.length; i++) {
+        const p = paragraphs.item(i);
+        if (getParagraphText(p).trim() !== target)
             continue;
-        if (getParagraphText(child).trim() !== target)
-            continue;
-        const runs = child.getElementsByTagName('w:r');
+        const runs = p.getElementsByTagName('w:r');
         for (let i = 0; i < runs.length; i++) {
             ensureRunColor(runs.item(i), op.color);
         }

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

@@ -3,6 +3,10 @@
  *
  * For every paragraph whose w:pPr/w:pStyle/@w:val === style,
  * set run-level colour on every w:r in that paragraph.
+ *
+ * This now includes paragraphs inside tables and other containers,
+ * not just direct w:p children of w:body.
+ *
  * Does NOT modify word/styles.xml — only in-document run formatting.
  */
 import type { SetColorForStyleOp, OpResult } from '../types.js';

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

@@ -3,18 +3,22 @@
  *
  * For every paragraph whose w:pPr/w:pStyle/@w:val === style,
  * set run-level colour on every w:r in that paragraph.
+ *
+ * This now includes paragraphs inside tables and other containers,
+ * not just direct w:p children of w:body.
+ *
  * Does NOT modify word/styles.xml — only in-document run formatting.
  */
-import { getBodyChildren, getParagraphStyle, ensureRunColor } from '../dom.js';
+import { getParagraphStyle, ensureRunColor } from '../dom.js';
 export function applySetColorForStyle(body, op) {
-    const children = getBodyChildren(body);
+    // Traverse **all** paragraphs in the body.
+    const paragraphs = body.getElementsByTagName('w:p');
     let matched = 0;
-    for (const child of children) {
-        if (child.nodeName !== 'w:p')
-            continue;
-        if (getParagraphStyle(child) !== op.style)
+    for (let i = 0; i < paragraphs.length; i++) {
+        const p = paragraphs.item(i);
+        if (getParagraphStyle(p) !== op.style)
             continue;
-        const runs = child.getElementsByTagName('w:r');
+        const runs = p.getElementsByTagName('w:r');
         for (let i = 0; i < runs.length; i++) {
             ensureRunColor(runs.item(i), op.color);
         }

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

@@ -5,24 +5,14 @@
  * 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';
+import { getAllBodyTables, nodeListToArray, setCellTextPreservingStyles } 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) {
+    // Find the n‑th logical table in the body, including tables inside SDTs.
+    const tables = getAllBodyTables(body);
+    if (op.tableIndex < 0 || op.tableIndex >= tables.length) {
         return { op, status: 'skipped', matched: 0, reason: 'table_not_found' };
     }
+    const table = tables[op.tableIndex];
     // Find the n-th w:tr
     const rows = [];
     for (const child of nodeListToArray(table.childNodes)) {
@@ -44,29 +34,7 @@ export function applyTableSetCellText(body, op) {
         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' };
+    // Replace cell text while preserving ALL styles (colors, bold, italic, etc.)
+    setCellTextPreservingStyles(cell, op.text);
+    return { op, status: 'applied', matched: 1 };
 }

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

@@ -5,8 +5,8 @@
 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.
+ * Extracts paragraphs, tables (with full cell content), and images (references only, not binary).
+ * Every element gets a bodyChildIndex (among ALL w:body children).
  */
 export declare function readDocxOutline(filePath: string): Promise<ReadDocxResult>;
 /** Extract plain text from DOCX. */