@wonderwhy-er/desktop-commander 0.2.37 → 0.2.39

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

@@ -1,169 +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
- */
-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/docx/zip.d.ts

@@ -1,21 +0,0 @@
-/**
- * DOCX ZIP I/O — Single Responsibility: file ↔ zip ↔ xml.
- *
- * Every other module depends on these three functions for disk I/O;
- * none of them touch the file system directly.
- */
-import PizZip from 'pizzip';
-/**
- * Read a .docx file from disk and return a PizZip instance.
- */
-export declare function loadDocxZip(filePath: string): Promise<PizZip>;
-/**
- * Extract the raw XML string from word/document.xml inside the zip.
- * Throws if the entry is missing.
- */
-export declare function getDocumentXml(zip: PizZip): string;
-/**
- * Replace word/document.xml in the zip with new XML,
- * then write the whole archive to outputPath.
- */
-export declare function saveDocxZip(zip: PizZip, newDocumentXml: string, outputPath: string): Promise<void>;

package/dist/tools/docx/zip.js

@@ -1,35 +0,0 @@
-/**
- * DOCX ZIP I/O — Single Responsibility: file ↔ zip ↔ xml.
- *
- * Every other module depends on these three functions for disk I/O;
- * none of them touch the file system directly.
- */
-import fs from 'fs/promises';
-import PizZip from 'pizzip';
-/**
- * Read a .docx file from disk and return a PizZip instance.
- */
-export async function loadDocxZip(filePath) {
-    const buf = await fs.readFile(filePath);
-    return new PizZip(buf);
-}
-/**
- * Extract the raw XML string from word/document.xml inside the zip.
- * Throws if the entry is missing.
- */
-export function getDocumentXml(zip) {
-    const entry = zip.file('word/document.xml');
-    if (!entry) {
-        throw new Error('Invalid DOCX: missing word/document.xml');
-    }
-    return entry.asText();
-}
-/**
- * Replace word/document.xml in the zip with new XML,
- * then write the whole archive to outputPath.
- */
-export async function saveDocxZip(zip, newDocumentXml, outputPath) {
-    zip.file('word/document.xml', newDocumentXml);
-    const buf = zip.generate({ type: 'nodebuffer' });
-    await fs.writeFile(outputPath, buf);
-}

package/dist/tools/pdf-processor.js

@@ -1,3 +0,0 @@
-export {};
-// PDF processing is no longer needed - PDFs are handled like images as base64 documents
-// This file is kept for potential future enhancements but currently unused

package/dist/tools/search.d.ts

@@ -1,32 +0,0 @@
-export interface SearchResult {
-    file: string;
-    line: number;
-    match: string;
-}
-export declare function searchCode(options: {
-    rootPath: string;
-    pattern: string;
-    filePattern?: string;
-    ignoreCase?: boolean;
-    maxResults?: number;
-    includeHidden?: boolean;
-    contextLines?: number;
-}): Promise<SearchResult[]>;
-export declare function searchCodeFallback(options: {
-    rootPath: string;
-    pattern: string;
-    filePattern?: string;
-    ignoreCase?: boolean;
-    maxResults?: number;
-    excludeDirs?: string[];
-    contextLines?: number;
-}): Promise<SearchResult[]>;
-export declare function searchTextInFiles(options: {
-    rootPath: string;
-    pattern: string;
-    filePattern?: string;
-    ignoreCase?: boolean;
-    maxResults?: number;
-    includeHidden?: boolean;
-    contextLines?: number;
-}): Promise<SearchResult[]>;

package/dist/tools/search.js

@@ -1,202 +0,0 @@
-import { spawn } from 'child_process';
-import path from 'path';
-import fs from 'fs/promises';
-import { validatePath } from './filesystem.js';
-import { rgPath } from '@vscode/ripgrep';
-import { capture } from "../utils/capture.js";
-// Function to search file contents using ripgrep
-export async function searchCode(options) {
-    const { rootPath, pattern, filePattern, ignoreCase = true, maxResults = 1000, includeHidden = false, contextLines = 0 } = options;
-    // Validate path for security
-    const validPath = await validatePath(rootPath);
-    // Build command arguments
-    const args = [
-        '--json', // Output in JSON format for easier parsing
-        '--line-number', // Include line numbers
-    ];
-    if (ignoreCase) {
-        args.push('-i');
-    }
-    if (maxResults) {
-        args.push('-m', maxResults.toString());
-    }
-    if (includeHidden) {
-        args.push('--hidden');
-    }
-    if (contextLines > 0) {
-        args.push('-C', contextLines.toString());
-    }
-    if (filePattern) {
-        const patterns = filePattern
-            .split('|')
-            .map(p => p.trim()) // remove surrounding spaces
-            .filter(Boolean); // drop empty tokens
-        // If all patterns were empty, return no results
-        if (patterns.length === 0) {
-            return [];
-        }
-        patterns.forEach(p => args.push('-g', p));
-    }
-    // Add pattern and path
-    args.push(pattern, validPath);
-    // Run ripgrep command
-    return new Promise((resolve, reject) => {
-        const results = [];
-        const rg = spawn(rgPath, args);
-        let stdoutBuffer = '';
-        // Store a reference to the child process for potential termination
-        const childProcess = rg;
-        // Store in a process list - this could be expanded to a global registry
-        // of running search processes if needed for management
-        globalThis.currentSearchProcess = childProcess;
-        rg.stdout.on('data', (data) => {
-            stdoutBuffer += data.toString();
-        });
-        rg.stderr.on('data', (data) => {
-            console.error(`ripgrep error: ${data}`);
-        });
-        rg.on('close', (code) => {
-            // Clean up the global reference
-            if (globalThis.currentSearchProcess === childProcess) {
-                delete globalThis.currentSearchProcess;
-            }
-            if (code === 0 || code === 1) {
-                // Process the buffered output
-                const lines = stdoutBuffer.trim().split('\n');
-                for (const line of lines) {
-                    if (!line)
-                        continue;
-                    try {
-                        const result = JSON.parse(line);
-                        if (result.type === 'match') {
-                            result.data.submatches.forEach((submatch) => {
-                                results.push({
-                                    file: result.data.path.text,
-                                    line: result.data.line_number,
-                                    match: submatch.match.text
-                                });
-                            });
-                        }
-                        else if (result.type === 'context' && contextLines > 0) {
-                            results.push({
-                                file: result.data.path.text,
-                                line: result.data.line_number,
-                                match: result.data.lines.text.trim()
-                            });
-                        }
-                    }
-                    catch (error) {
-                        const errorMessage = error instanceof Error ? error.message : String(error);
-                        capture('server_request_error', { error: `Error parsing ripgrep output: ${errorMessage}` });
-                        console.error(`Error parsing ripgrep output: ${errorMessage}`);
-                    }
-                }
-                resolve(results);
-            }
-            else {
-                reject(new Error(`ripgrep process exited with code ${code}`));
-            }
-        });
-    });
-}
-// Fallback implementation using Node.js for environments without ripgrep
-export async function searchCodeFallback(options) {
-    const { rootPath, pattern, filePattern, ignoreCase = true, maxResults = 1000, excludeDirs = ['node_modules', '.git'], contextLines = 0 } = options;
-    const validPath = await validatePath(rootPath);
-    const results = [];
-    const regex = new RegExp(pattern, ignoreCase ? 'i' : '');
-    // Handle filePattern similarly to main implementation
-    let fileRegex = null;
-    if (filePattern) {
-        const patterns = filePattern
-            .split('|')
-            .map(p => p.trim())
-            .filter(Boolean);
-        // If all patterns were empty, return no results
-        if (patterns.length === 0) {
-            return [];
-        }
-        // Create a regex that matches any of the patterns
-        const combinedPattern = patterns.map(p => p.replace(/\./g, '\\.').replace(/\*/g, '.*').replace(/\?/g, '.')).join('|');
-        fileRegex = new RegExp(`^(${combinedPattern})$`);
-    }
-    async function searchDir(dirPath) {
-        if (results.length >= maxResults)
-            return;
-        try {
-            const entries = await fs.readdir(dirPath, { withFileTypes: true });
-            for (const entry of entries) {
-                if (results.length >= maxResults)
-                    break;
-                const fullPath = path.join(dirPath, entry.name);
-                try {
-                    await validatePath(fullPath);
-                    if (entry.isDirectory()) {
-                        if (!excludeDirs.includes(entry.name)) {
-                            await searchDir(fullPath);
-                        }
-                    }
-                    else if (entry.isFile()) {
-                        if (!fileRegex || fileRegex.test(entry.name)) {
-                            const content = await fs.readFile(fullPath, 'utf-8');
-                            const lines = content.split('\n');
-                            for (let i = 0; i < lines.length; i++) {
-                                if (regex.test(lines[i])) {
-                                    // Add the matched line
-                                    results.push({
-                                        file: fullPath,
-                                        line: i + 1,
-                                        match: lines[i].trim()
-                                    });
-                                    // Add context lines
-                                    if (contextLines > 0) {
-                                        const startIdx = Math.max(0, i - contextLines);
-                                        const endIdx = Math.min(lines.length - 1, i + contextLines);
-                                        for (let j = startIdx; j <= endIdx; j++) {
-                                            if (j !== i) { // Skip the match line as it's already added
-                                                results.push({
-                                                    file: fullPath,
-                                                    line: j + 1,
-                                                    match: lines[j].trim()
-                                                });
-                                            }
-                                        }
-                                    }
-                                    if (results.length >= maxResults)
-                                        break;
-                                }
-                            }
-                        }
-                    }
-                }
-                catch (error) {
-                    // Skip files/directories we can't access
-                    continue;
-                }
-            }
-        }
-        catch (error) {
-            // Skip directories we can't read
-        }
-    }
-    await searchDir(validPath);
-    return results;
-}
-// Main function that tries ripgrep first, falls back to native implementation
-export async function searchTextInFiles(options) {
-    try {
-        // For better performance and consistency, prefer the search session manager
-        // when doing content search, but keep the original direct ripgrep approach as primary
-        return await searchCode(options);
-    }
-    catch (error) {
-        capture('searchTextInFiles_ripgrep_fallback', {
-            error: error instanceof Error ? error.message : 'Unknown error'
-        });
-        // Use consistent exclusions - remove 'dist' to match ripgrep behavior
-        return searchCodeFallback({
-            ...options,
-            excludeDirs: ['node_modules', '.git']
-        });
-    }
-}

package/dist/ui/file-preview/src/app.d.ts

@@ -1,4 +0,0 @@
-import type { FilePreviewStructuredContent } from '../../../types.js';
-import type { HtmlPreviewMode } from './types.js';
-export declare function renderApp(container: HTMLElement, payload?: FilePreviewStructuredContent, htmlMode?: HtmlPreviewMode, expandedState?: boolean): void;
-export declare function bootstrapApp(): void;