@wonderwhy-er/desktop-commander 0.2.36 → 0.2.38

package/dist/tools/docx/read.js

@@ -5,7 +5,7 @@
 import fs from 'fs/promises';
 import PizZip from 'pizzip';
 import { DOMParser, XMLSerializer } from '@xmldom/xmldom';
-import { nodeListToArray, getParagraphText, getParagraphStyle, getBody, getBodyChildren, countTables, countImages, } from './dom.js';
+import { nodeListToArray, getParagraphText, getParagraphStyle, getBody, getBodyChildren, getAllBodyTables, countImages, getTableContent, getTableStyle, getImageReference, } from './dom.js';
 // ═══════════════════════════════════════════════════════════════════════
 // Internal helpers
 // ═══════════════════════════════════════════════════════════════════════
@@ -16,10 +16,59 @@ async function loadDocx(path) {
 // ═══════════════════════════════════════════════════════════════════════
 // readDocxOutline — compact JSON outline (used by read_docx tool)
 // ═══════════════════════════════════════════════════════════════════════
+/**
+ * Extract image relationship mappings from word/_rels/document.xml.rels.
+ * Returns a map of rId -> mediaPath (e.g., "rId1" -> "word/media/image1.png").
+ */
+function extractImageRelationships(zip) {
+    const relsPath = 'word/_rels/document.xml.rels';
+    const relsFile = zip.file(relsPath);
+    if (!relsFile)
+        return new Map();
+    const relsXml = relsFile.asText();
+    const relsDom = new DOMParser().parseFromString(relsXml, 'application/xml');
+    const relationships = relsDom.getElementsByTagName('Relationship');
+    const imageMap = new Map();
+    for (const rel of nodeListToArray(relationships)) {
+        const relEl = rel;
+        const type = relEl.getAttribute('Type');
+        const id = relEl.getAttribute('Id');
+        const target = relEl.getAttribute('Target');
+        // Check if it's an image relationship
+        if (type &&
+            type.includes('/image') &&
+            id &&
+            target &&
+            target.startsWith('media/')) {
+            imageMap.set(id, `word/${target}`);
+        }
+    }
+    return imageMap;
+}
+/**
+ * Extract alt text from wp:docPr/@descr or pic:cNvPr/@descr in a drawing element.
+ */
+function getImageAltText(drawing) {
+    // Try wp:docPr/@descr first
+    const docPr = drawing.getElementsByTagName('wp:docPr').item(0);
+    if (docPr) {
+        const descr = docPr.getAttribute('descr');
+        if (descr)
+            return descr;
+    }
+    // Fall back to pic:cNvPr/@descr
+    const cNvPr = drawing.getElementsByTagName('pic:cNvPr').item(0);
+    if (cNvPr) {
+        const descr = cNvPr.getAttribute('descr');
+        if (descr)
+            return descr;
+    }
+    return undefined;
+}
 /**
  * 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 async function readDocxOutline(filePath) {
     const zip = await loadDocx(filePath);
@@ -30,31 +79,102 @@ export async function readDocxOutline(filePath) {
     const dom = new DOMParser().parseFromString(xmlStr, 'application/xml');
     const body = getBody(dom);
     const children = getBodyChildren(body);
+    // Extract image relationships (rId -> mediaPath)
+    const imageRelationships = extractImageRelationships(zip);
     const paragraphs = [];
+    const tables = [];
+    const images = [];
     const stylesSet = new Set();
     let paragraphIndex = 0;
+    let tableIndex = 0;
+    let imageIndex = 0;
     for (let i = 0; i < children.length; i++) {
         const child = children[i];
-        if (child.nodeName !== 'w:p')
-            continue;
-        const text = getParagraphText(child).trim();
-        const style = getParagraphStyle(child);
-        if (style)
-            stylesSet.add(style);
-        paragraphs.push({
-            bodyChildIndex: i,
-            paragraphIndex,
-            style,
-            text,
-        });
-        paragraphIndex++;
+        if (child.nodeName === 'w:p') {
+            // Extract paragraph
+            const text = getParagraphText(child).trim();
+            const style = getParagraphStyle(child);
+            if (style)
+                stylesSet.add(style);
+            paragraphs.push({
+                bodyChildIndex: i,
+                paragraphIndex,
+                style,
+                text,
+            });
+            paragraphIndex++;
+            // Check if paragraph contains an image (w:drawing)
+            const drawings = child.getElementsByTagName('w:drawing');
+            for (let d = 0; d < drawings.length; d++) {
+                const drawing = drawings.item(d);
+                const imgRef = getImageReference(drawing);
+                if (imgRef.rId) {
+                    const mediaPath = imageRelationships.get(imgRef.rId);
+                    if (mediaPath) {
+                        const altText = getImageAltText(drawing);
+                        images.push({
+                            bodyChildIndex: i,
+                            imageIndex,
+                            mediaPath,
+                            rId: imgRef.rId,
+                            altText,
+                        });
+                        imageIndex++;
+                    }
+                }
+            }
+        }
+        else if (child.nodeName === 'w:tbl') {
+            // Extract table content (direct table in body)
+            const tableContent = getTableContent(child);
+            const style = getTableStyle(child);
+            if (style)
+                stylesSet.add(style);
+            tables.push({
+                bodyChildIndex: i,
+                tableIndex,
+                style,
+                headers: tableContent.headers,
+                rows: tableContent.rows,
+            });
+            tableIndex++;
+        }
+        else if (child.nodeName === 'w:sdt') {
+            // Structured document tag: look inside w:sdtContent for tables that
+            // are logically at this body position.
+            const sdtContent = child.getElementsByTagName('w:sdtContent').item(0);
+            if (sdtContent) {
+                for (const sdtChild of nodeListToArray(sdtContent.childNodes)) {
+                    if (sdtChild.nodeType === 1 &&
+                        sdtChild.nodeName === 'w:tbl') {
+                        const tbl = sdtChild;
+                        const tableContent = getTableContent(tbl);
+                        const style = getTableStyle(tbl);
+                        if (style)
+                            stylesSet.add(style);
+                        tables.push({
+                            bodyChildIndex: i,
+                            tableIndex,
+                            style,
+                            headers: tableContent.headers,
+                            rows: tableContent.rows,
+                        });
+                        tableIndex++;
+                    }
+                }
+            }
+        }
     }
     return {
         path: filePath,
         paragraphs,
+        tables,
+        images,
         stylesSeen: [...stylesSet].sort(),
         counts: {
-            tables: countTables(children),
+            // Table count should reflect all logical tables, including those
+            // wrapped in SDTs, so we reuse the same helper used by ops.
+            tables: getAllBodyTables(body).length,
             images: countImages(body),
             bodyChildren: children.length,
         },

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

@@ -41,9 +41,25 @@ export interface ParagraphOutline {
     style: string | null;
     text: string;
 }
+export interface TableOutline {
+    bodyChildIndex: number;
+    tableIndex: number;
+    style: string | null;
+    headers?: string[];
+    rows: string[][];
+}
+export interface ImageOutline {
+    bodyChildIndex: number;
+    imageIndex: number;
+    mediaPath: string;
+    rId: string;
+    altText?: string;
+}
 export interface ReadDocxResult {
     path: string;
     paragraphs: ParagraphOutline[];
+    tables: TableOutline[];
+    images: ImageOutline[];
     stylesSeen: string[];
     counts: {
         tables: number;
@@ -112,6 +128,11 @@ export interface TableSetCellTextOp {
     col: number;
     text: string;
 }
+export interface ReplaceTableCellTextOp {
+    type: 'replace_table_cell_text';
+    from: string;
+    to: string;
+}
 export interface ReplaceHyperlinkUrlOp {
     type: 'replace_hyperlink_url';
     oldUrl: string;
@@ -152,7 +173,7 @@ export interface InsertImageOp {
     /** Alt text for accessibility */
     altText?: string;
 }
-export type DocxOp = ReplaceParagraphTextExactOp | ReplaceParagraphAtBodyIndexOp | SetColorForStyleOp | SetColorForParagraphExactOp | SetParagraphStyleAtBodyIndexOp | InsertParagraphAfterTextOp | DeleteParagraphAtBodyIndexOp | TableSetCellTextOp | ReplaceHyperlinkUrlOp | HeaderReplaceTextExactOp | InsertTableOp | InsertImageOp;
+export type DocxOp = ReplaceParagraphTextExactOp | ReplaceParagraphAtBodyIndexOp | SetColorForStyleOp | SetColorForParagraphExactOp | SetParagraphStyleAtBodyIndexOp | InsertParagraphAfterTextOp | DeleteParagraphAtBodyIndexOp | TableSetCellTextOp | ReplaceTableCellTextOp | ReplaceHyperlinkUrlOp | HeaderReplaceTextExactOp | InsertTableOp | InsertImageOp;
 export interface OpResult {
     op: DocxOp;
     status: 'applied' | 'skipped';
@@ -164,10 +185,18 @@ export interface DocxContentParagraph {
     text: string;
     style?: string | null;
 }
+/**
+ * Cell content can be:
+ * - A string (simple case, creates one paragraph)
+ * - An array of paragraphs (allows multiple paragraphs with different styles per cell)
+ */
+export type DocxTableCellContent = string | DocxContentParagraph[];
 export interface DocxContentTable {
     type: 'table';
-    headers?: string[];
-    rows: string[][];
+    /** Header cells - can be strings or arrays of paragraphs */
+    headers?: DocxTableCellContent[];
+    /** Data rows - each cell can be a string or array of paragraphs */
+    rows: DocxTableCellContent[][];
     colWidths?: number[];
     style?: string;
 }

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

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

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

@@ -0,0 +1,63 @@
+/**
+ * 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

@@ -0,0 +1,56 @@
+/**
+ * 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;
+}>;

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

@@ -0,0 +1,169 @@
+/**
+ * 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
+ */
+import fs from 'fs/promises';
+import PizZip from 'pizzip';
+// ════════════════════════════════════════════════════════════════
+// XML pretty-print / compact
+// ════════════════════════════════════════════════════════════════
+/**
+ * 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 function prettyPrintXml(xml) {
+    // Split between adjacent tags: "><" → ">\n<"
+    // But NOT inside text content — we only split where > is immediately followed by <
+    const parts = xml.split(/(?<=>)(?=<)/);
+    const lines = [];
+    let depth = 0;
+    for (const part of parts) {
+        const trimmed = part.trim();
+        if (!trimmed)
+            continue;
+        const isClosing = trimmed.startsWith('</');
+        const isSelfClosing = trimmed.endsWith('/>');
+        const isProcessingInstruction = trimmed.startsWith('<?');
+        // Inline: opens and closes on same fragment, e.g. <w:t>foo</w:t>
+        const isInline = !isClosing && !isSelfClosing && trimmed.includes('</');
+        if (isClosing) {
+            depth = Math.max(0, depth - 1);
+        }
+        lines.push('  '.repeat(depth) + trimmed);
+        if (!isClosing && !isSelfClosing && !isInline && !isProcessingInstruction) {
+            depth++;
+        }
+    }
+    return lines.join('\n');
+}
+/**
+ * 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 function compactXml(prettyXml) {
+    const lines = prettyXml.split('\n');
+    return lines.map(l => l.trimStart()).join('');
+}
+/**
+ * Read the document.xml from a DOCX as pretty-printed, line-based XML.
+ * Supports offset/length pagination just like text file reading.
+ */
+export async function readDocxXml(filePath, offset = 0, length) {
+    const buf = await fs.readFile(filePath);
+    const zip = new PizZip(buf);
+    const docFile = zip.file('word/document.xml');
+    if (!docFile)
+        throw new Error('Invalid DOCX: missing word/document.xml');
+    const rawXml = docFile.asText();
+    const pretty = prettyPrintXml(rawXml);
+    const allLines = pretty.split('\n');
+    const totalLines = allLines.length;
+    // Apply pagination
+    let startLine;
+    let sliceLength;
+    if (offset < 0) {
+        // Negative offset = tail (last N lines)
+        startLine = Math.max(0, totalLines + offset);
+        sliceLength = totalLines - startLine;
+    }
+    else {
+        startLine = offset;
+        sliceLength = length ?? totalLines;
+    }
+    const slicedLines = allLines.slice(startLine, startLine + sliceLength);
+    const content = slicedLines.join('\n');
+    return {
+        content,
+        lineCount: totalLines,
+        path: filePath,
+        rawSize: rawXml.length,
+    };
+}
+/**
+ * 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 async function editDocxXml(inputPath, outputPath, oldStr, newStr, expectedReplacements = 1) {
+    // 1. Read + pretty-print
+    const buf = await fs.readFile(inputPath);
+    const zip = new PizZip(buf);
+    const docFile = zip.file('word/document.xml');
+    if (!docFile)
+        throw new Error('Invalid DOCX: missing word/document.xml');
+    const rawXml = docFile.asText();
+    const pretty = prettyPrintXml(rawXml);
+    // 2. Normalize the search string's indentation to match our pretty-print.
+    //    The caller might copy lines from read_file output which uses the same
+    //    indentation, but just in case, we also try trimStart normalization.
+    let matchCount = countOccurrences(pretty, oldStr);
+    if (matchCount === 0) {
+        return {
+            status: 'no_match',
+            matchCount: 0,
+            outputPath,
+            message: `Search string not found in ${inputPath}`,
+        };
+    }
+    if (matchCount !== expectedReplacements) {
+        return {
+            status: 'unexpected_count',
+            matchCount,
+            outputPath,
+            message: `Expected ${expectedReplacements} occurrence(s) but found ${matchCount}. ` +
+                `Add more surrounding context to make the search string unique, ` +
+                `or set expected_replacements to ${matchCount} to replace all.`,
+        };
+    }
+    // 3. Apply edit(s)
+    let edited = pretty;
+    if (expectedReplacements === 1) {
+        const idx = edited.indexOf(oldStr);
+        edited = edited.substring(0, idx) + newStr + edited.substring(idx + oldStr.length);
+    }
+    else {
+        edited = edited.split(oldStr).join(newStr);
+    }
+    // 4. Compact + repack
+    const compacted = compactXml(edited);
+    zip.file('word/document.xml', compacted);
+    const outBuf = zip.generate({
+        type: 'nodebuffer',
+        compression: 'DEFLATE',
+        compressionOptions: { level: 6 },
+    });
+    await fs.writeFile(outputPath, outBuf);
+    return {
+        status: 'applied',
+        matchCount,
+        outputPath,
+    };
+}
+// ════════════════════════════════════════════════════════════════
+// Helpers
+// ════════════════════════════════════════════════════════════════
+function countOccurrences(haystack, needle) {
+    let count = 0;
+    let pos = haystack.indexOf(needle);
+    while (pos !== -1) {
+        count++;
+        pos = haystack.indexOf(needle, pos + 1);
+    }
+    return count;
+}

package/dist/tools/edit.js

@@ -305,28 +305,36 @@ function highlightDifferences(expected, actual) {
  */
 export async function handleEditBlock(args) {
     const parsed = EditBlockArgsSchema.parse(args);
-    // Structured files: Range rewrite
     // Note: Check for truthy range to handle empty strings from AI clients that send all optional params
     const hasRange = parsed.range !== undefined && parsed.range !== '';
     const hasContent = parsed.content !== undefined && parsed.content !== '';
+    // Validate path and resolve handler once — used by both dispatch paths below
+    let validatedPath;
+    let handler;
+    try {
+        validatedPath = await validatePath(parsed.file_path);
+        const { getFileHandler } = await import('../utils/files/factory.js');
+        handler = await getFileHandler(validatedPath);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return createErrorResponse(errorMessage);
+    }
+    const hasEditRange = 'editRange' in handler && typeof handler.editRange === 'function';
+    // Path 1: Range rewrite (Excel, etc.) — range + content
     if (hasRange && hasContent) {
-        try {
-            // Validate path before any filesystem operations
-            const validatedPath = await validatePath(parsed.file_path);
-            const { getFileHandler } = await import('../utils/files/factory.js');
-            const handler = await getFileHandler(validatedPath);
-            // Parse content if it's a JSON string (AI often sends arrays as JSON strings)
-            let content = parsed.content;
-            if (typeof content === 'string') {
-                try {
-                    content = JSON.parse(content);
-                }
-                catch {
-                    // Leave as-is if not valid JSON - let handler decide
-                }
+        // Parse content if it's a JSON string (AI often sends arrays as JSON strings)
+        let content = parsed.content;
+        if (typeof content === 'string') {
+            try {
+                content = JSON.parse(content);
             }
-            // Check if handler supports range editing
-            if ('editRange' in handler && typeof handler.editRange === 'function') {
+            catch {
+                // Leave as-is if not valid JSON - let handler decide
+            }
+        }
+        if (hasEditRange) {
+            try {
                 // parsed.range is guaranteed non-empty string by hasRange check above
                 await handler.editRange(validatedPath, parsed.range, content, parsed.options);
                 return {
@@ -336,23 +344,45 @@ export async function handleEditBlock(args) {
                         }],
                 };
             }
-            else {
-                return createErrorResponse(`Range-based editing not supported for ${parsed.file_path}. For text files, use old_string and new_string parameters instead. If your client requires range/content parameters, set them to empty strings ("").`);
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                return createErrorResponse(errorMessage);
+            }
+        }
+        return createErrorResponse(`Range-based editing not supported for ${parsed.file_path}. For text files, use old_string and new_string parameters instead. If your client requires range/content parameters, set them to empty strings ("").`);
+    }
+    // Path 2: Text replacement — old_string + new_string
+    if (parsed.old_string === undefined || parsed.new_string === undefined) {
+        return createErrorResponse(`Text replacement requires both old_string and new_string parameters`);
+    }
+    // If the handler implements editRange it owns text-replacement for its file type
+    // (e.g. DocxFileHandler does find/replace on pretty-printed XML rather than raw bytes).
+    // Plain text files fall through to performSearchReplace.
+    if (hasEditRange) {
+        try {
+            const result = await handler.editRange(validatedPath, '', {
+                old_string: parsed.old_string,
+                new_string: parsed.new_string,
+                expected_replacements: parsed.expected_replacements,
+            });
+            if (result.success) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Successfully applied ${result.editsApplied} edit(s) to ${parsed.file_path}`
+                        }],
+                };
             }
+            const errorMsg = result.errors?.map(e => e.error).join('; ') || 'Unknown error';
+            return createErrorResponse(errorMsg);
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
             return createErrorResponse(errorMessage);
         }
     }
-    // Text files: String replacement
-    // Validate required parameters for text replacement
-    if (parsed.old_string === undefined || parsed.new_string === undefined) {
-        return createErrorResponse(`Text replacement requires both old_string and new_string parameters`);
-    }
-    const searchReplace = {
+    return performSearchReplace(parsed.file_path, {
         search: parsed.old_string,
         replace: parsed.new_string
-    };
-    return performSearchReplace(parsed.file_path, searchReplace, parsed.expected_replacements);
+    }, parsed.expected_replacements);
 }