@wonderwhy-er/desktop-commander 0.2.23 → 0.2.24

package/dist/utils/files/pdf.d.ts

@@ -0,0 +1,32 @@
+/**
+ * PDF File Handler
+ * Implements FileHandler interface for PDF documents
+ */
+import { FileHandler, FileResult, FileInfo, ReadOptions, EditResult } from './base.js';
+/**
+ * File handler for PDF documents
+ * Extracts text and images, supports page-based pagination
+ */
+export declare class PdfFileHandler implements FileHandler {
+    private readonly extensions;
+    /**
+     * Check if this handler can handle the given file
+     */
+    canHandle(path: string): boolean;
+    /**
+     * Read PDF content - extracts text as markdown with images
+     */
+    read(path: string, options?: ReadOptions): Promise<FileResult>;
+    /**
+     * Write PDF - creates from markdown or operations
+     */
+    write(path: string, content: any, mode?: 'rewrite' | 'append'): Promise<void>;
+    /**
+     * Edit PDF by range/operations
+     */
+    editRange(path: string, range: string, content: any, options?: Record<string, any>): Promise<EditResult>;
+    /**
+     * Get PDF file information
+     */
+    getInfo(path: string): Promise<FileInfo>;
+}

package/dist/utils/files/pdf.js

@@ -0,0 +1,142 @@
+/**
+ * PDF File Handler
+ * Implements FileHandler interface for PDF documents
+ */
+import fs from 'fs/promises';
+import { parsePdfToMarkdown, parseMarkdownToPdf, editPdf } from '../../tools/pdf/index.js';
+/**
+ * File handler for PDF documents
+ * Extracts text and images, supports page-based pagination
+ */
+export class PdfFileHandler {
+    constructor() {
+        this.extensions = ['.pdf'];
+    }
+    /**
+     * Check if this handler can handle the given file
+     */
+    canHandle(path) {
+        const ext = path.toLowerCase();
+        return this.extensions.some(e => ext.endsWith(e));
+    }
+    /**
+     * Read PDF content - extracts text as markdown with images
+     */
+    async read(path, options) {
+        const { offset = 0, length } = options ?? {};
+        try {
+            // Use existing PDF parser
+            // Ensure we pass a valid PageRange or number array
+            // If length is undefined, we assume "rest of file" which requires careful handling.
+            // If length is defined, we pass { offset, length }.
+            // If neither, we pass empty array (all pages).
+            // Note: offset defaults to 0 if undefined.
+            let range;
+            if (length !== undefined) {
+                range = { offset, length };
+            }
+            else if (offset > 0) {
+                // If offset provided but no length, try to read reasonable amount or all?
+                // PageRange requires length. Let's assume 0 means "all" or use a large number?
+                // Looking at pdf2md implementation, it uses generatePageNumbers(offset, length, total).
+                // We'll pass 0 for length to imply "rest" if supported, or just undefined length if valid.
+                // But typescript requires length.
+                range = { offset, length: 0 };
+            }
+            else {
+                range = [];
+            }
+            const pdfResult = await parsePdfToMarkdown(path, range);
+            return {
+                content: '', // Main content is in metadata.pages
+                mimeType: 'application/pdf',
+                metadata: {
+                    isPdf: true,
+                    author: pdfResult.metadata.author,
+                    title: pdfResult.metadata.title,
+                    totalPages: pdfResult.metadata.totalPages,
+                    pages: pdfResult.pages
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                content: `Error reading PDF: ${errorMessage}`,
+                mimeType: 'text/plain',
+                metadata: {
+                    error: true,
+                    errorMessage
+                }
+            };
+        }
+    }
+    /**
+     * Write PDF - creates from markdown or operations
+     */
+    async write(path, content, mode) {
+        // If content is string, treat as markdown to convert
+        if (typeof content === 'string') {
+            await parseMarkdownToPdf(content, path);
+        }
+        else if (Array.isArray(content)) {
+            // Array of operations - use editPdf
+            const resultBuffer = await editPdf(path, content);
+            await fs.writeFile(path, resultBuffer);
+        }
+        else {
+            throw new Error('PDF write requires markdown string or array of operations');
+        }
+    }
+    /**
+     * Edit PDF by range/operations
+     */
+    async editRange(path, range, content, options) {
+        try {
+            // For PDF, range editing isn't directly supported
+            // Could interpret range as page numbers in future
+            const resultBuffer = await editPdf(path, content);
+            await fs.writeFile(options?.outputPath || path, resultBuffer);
+            return { success: true, editsApplied: 1 };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                success: false,
+                editsApplied: 0,
+                errors: [{ location: range, error: errorMessage }]
+            };
+        }
+    }
+    /**
+     * Get PDF file information
+     */
+    async getInfo(path) {
+        const stats = await fs.stat(path);
+        // Get basic PDF metadata
+        let metadata = { isPdf: true };
+        try {
+            const pdfResult = await parsePdfToMarkdown(path, { offset: 0, length: 0 }); // Just metadata
+            metadata = {
+                isPdf: true,
+                title: pdfResult.metadata.title,
+                author: pdfResult.metadata.author,
+                totalPages: pdfResult.metadata.totalPages
+            };
+        }
+        catch {
+            // If we can't parse, just return basic info
+        }
+        return {
+            size: stats.size,
+            created: stats.birthtime,
+            modified: stats.mtime,
+            accessed: stats.atime,
+            isDirectory: false,
+            isFile: true,
+            permissions: (stats.mode & 0o777).toString(8),
+            fileType: 'binary',
+            metadata
+        };
+    }
+}

package/dist/utils/files/text.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Text file handler
+ * Handles reading, writing, and editing text files
+ *
+ * Binary detection is handled at the factory level (factory.ts) using isBinaryFile.
+ * This handler only receives files that have been confirmed as text.
+ *
+ * TECHNICAL DEBT:
+ * This handler is missing editRange() - text search/replace logic currently lives in
+ * src/tools/edit.ts (performSearchReplace function) instead of here.
+ *
+ * For architectural consistency with ExcelFileHandler.editRange(), the fuzzy
+ * search/replace logic should be moved here. See comment in src/tools/edit.ts.
+ */
+import { FileHandler, ReadOptions, FileResult, FileInfo } from './base.js';
+/**
+ * Text file handler implementation
+ * Binary detection is done at the factory level - this handler assumes file is text
+ */
+export declare class TextFileHandler implements FileHandler {
+    canHandle(_path: string): boolean;
+    read(filePath: string, options?: ReadOptions): Promise<FileResult>;
+    write(path: string, content: string, mode?: 'rewrite' | 'append'): Promise<void>;
+    getInfo(path: string): Promise<FileInfo>;
+    /**
+     * Count lines in text content
+     * Made static and public for use by other modules (e.g., writeFile telemetry in filesystem.ts)
+     */
+    static countLines(content: string): number;
+    /**
+     * Get file line count (for files under size limit)
+     */
+    private getFileLineCount;
+    /**
+     * Generate enhanced status message
+     */
+    private generateEnhancedStatusMessage;
+    /**
+     * Split text into lines while preserving line endings
+     * Made static and public for use by other modules (e.g., readFileInternal in filesystem.ts)
+     */
+    static splitLinesPreservingEndings(content: string): string[];
+    /**
+     * Read file with smart positioning for optimal performance
+     */
+    private readFileWithSmartPositioning;
+    /**
+     * Read last N lines efficiently by reading file backwards
+     */
+    private readLastNLinesReverse;
+    /**
+     * Read from end using readline with circular buffer
+     */
+    private readFromEndWithReadline;
+    /**
+     * Read from start/middle using readline
+     */
+    private readFromStartWithReadline;
+    /**
+     * Read from estimated byte position for very large files
+     */
+    private readFromEstimatedPosition;
+}

package/dist/utils/files/text.js

@@ -0,0 +1,357 @@
+/**
+ * Text file handler
+ * Handles reading, writing, and editing text files
+ *
+ * Binary detection is handled at the factory level (factory.ts) using isBinaryFile.
+ * This handler only receives files that have been confirmed as text.
+ *
+ * TECHNICAL DEBT:
+ * This handler is missing editRange() - text search/replace logic currently lives in
+ * src/tools/edit.ts (performSearchReplace function) instead of here.
+ *
+ * For architectural consistency with ExcelFileHandler.editRange(), the fuzzy
+ * search/replace logic should be moved here. See comment in src/tools/edit.ts.
+ */
+import fs from "fs/promises";
+import { createReadStream } from 'fs';
+import { createInterface } from 'readline';
+// TODO: Centralize these constants with filesystem.ts to avoid silent drift
+// These duplicate concepts from filesystem.ts and should be moved to a shared
+// constants module (e.g., src/utils/files/constants.ts) during reorganization
+const FILE_SIZE_LIMITS = {
+    LARGE_FILE_THRESHOLD: 10 * 1024 * 1024, // 10MB
+    LINE_COUNT_LIMIT: 10 * 1024 * 1024, // 10MB for line counting
+};
+const READ_PERFORMANCE_THRESHOLDS = {
+    SMALL_READ_THRESHOLD: 100, // For very small reads
+    DEEP_OFFSET_THRESHOLD: 1000, // For byte estimation
+    SAMPLE_SIZE: 10000, // Sample size for estimation
+    CHUNK_SIZE: 8192, // 8KB chunks for reverse reading
+};
+/**
+ * Text file handler implementation
+ * Binary detection is done at the factory level - this handler assumes file is text
+ */
+export class TextFileHandler {
+    canHandle(_path) {
+        // Text handler accepts all files that pass the factory's binary check
+        // The factory routes binary files to BinaryFileHandler before reaching here
+        return true;
+    }
+    async read(filePath, options) {
+        const offset = options?.offset ?? 0;
+        const length = options?.length ?? 1000; // Default from config
+        const includeStatusMessage = options?.includeStatusMessage ?? true;
+        // Binary detection is done at factory level - just read as text
+        return this.readFileWithSmartPositioning(filePath, offset, length, 'text/plain', includeStatusMessage);
+    }
+    async write(path, content, mode = 'rewrite') {
+        if (mode === 'append') {
+            await fs.appendFile(path, content);
+        }
+        else {
+            await fs.writeFile(path, content);
+        }
+    }
+    async getInfo(path) {
+        const stats = await fs.stat(path);
+        const info = {
+            size: stats.size,
+            created: stats.birthtime,
+            modified: stats.mtime,
+            accessed: stats.atime,
+            isDirectory: stats.isDirectory(),
+            isFile: stats.isFile(),
+            permissions: stats.mode.toString(8).slice(-3),
+            fileType: 'text',
+            metadata: {}
+        };
+        // For text files that aren't too large, count lines
+        if (stats.isFile() && stats.size < FILE_SIZE_LIMITS.LINE_COUNT_LIMIT) {
+            try {
+                const content = await fs.readFile(path, 'utf8');
+                const lineCount = TextFileHandler.countLines(content);
+                info.metadata.lineCount = lineCount;
+            }
+            catch (error) {
+                // If reading fails, skip line count
+            }
+        }
+        return info;
+    }
+    // ========================================================================
+    // Private Helper Methods (extracted from filesystem.ts)
+    // ========================================================================
+    /**
+     * Count lines in text content
+     * Made static and public for use by other modules (e.g., writeFile telemetry in filesystem.ts)
+     */
+    static countLines(content) {
+        return content.split('\n').length;
+    }
+    /**
+     * Get file line count (for files under size limit)
+     */
+    async getFileLineCount(filePath) {
+        try {
+            const stats = await fs.stat(filePath);
+            if (stats.size < FILE_SIZE_LIMITS.LINE_COUNT_LIMIT) {
+                const content = await fs.readFile(filePath, 'utf8');
+                return TextFileHandler.countLines(content);
+            }
+        }
+        catch (error) {
+            // If we can't read the file, return undefined
+        }
+        return undefined;
+    }
+    /**
+     * Generate enhanced status message
+     */
+    generateEnhancedStatusMessage(readLines, offset, totalLines, isNegativeOffset = false) {
+        if (isNegativeOffset) {
+            if (totalLines !== undefined) {
+                return `[Reading last ${readLines} lines (total: ${totalLines} lines)]`;
+            }
+            else {
+                return `[Reading last ${readLines} lines]`;
+            }
+        }
+        else {
+            if (totalLines !== undefined) {
+                const endLine = offset + readLines;
+                const remainingLines = Math.max(0, totalLines - endLine);
+                if (offset === 0) {
+                    return `[Reading ${readLines} lines from start (total: ${totalLines} lines, ${remainingLines} remaining)]`;
+                }
+                else {
+                    return `[Reading ${readLines} lines from line ${offset} (total: ${totalLines} lines, ${remainingLines} remaining)]`;
+                }
+            }
+            else {
+                if (offset === 0) {
+                    return `[Reading ${readLines} lines from start]`;
+                }
+                else {
+                    return `[Reading ${readLines} lines from line ${offset}]`;
+                }
+            }
+        }
+    }
+    /**
+     * Split text into lines while preserving line endings
+     * Made static and public for use by other modules (e.g., readFileInternal in filesystem.ts)
+     */
+    static splitLinesPreservingEndings(content) {
+        if (!content)
+            return [''];
+        const lines = [];
+        let currentLine = '';
+        for (let i = 0; i < content.length; i++) {
+            const char = content[i];
+            currentLine += char;
+            if (char === '\n') {
+                lines.push(currentLine);
+                currentLine = '';
+            }
+            else if (char === '\r') {
+                if (i + 1 < content.length && content[i + 1] === '\n') {
+                    currentLine += content[i + 1];
+                    i++;
+                }
+                lines.push(currentLine);
+                currentLine = '';
+            }
+        }
+        if (currentLine) {
+            lines.push(currentLine);
+        }
+        return lines;
+    }
+    /**
+     * Read file with smart positioning for optimal performance
+     */
+    async readFileWithSmartPositioning(filePath, offset, length, mimeType, includeStatusMessage = true) {
+        const stats = await fs.stat(filePath);
+        const fileSize = stats.size;
+        const totalLines = await this.getFileLineCount(filePath);
+        // For negative offsets (tail behavior), use reverse reading
+        if (offset < 0) {
+            const requestedLines = Math.abs(offset);
+            if (fileSize > FILE_SIZE_LIMITS.LARGE_FILE_THRESHOLD &&
+                requestedLines <= READ_PERFORMANCE_THRESHOLDS.SMALL_READ_THRESHOLD) {
+                return await this.readLastNLinesReverse(filePath, requestedLines, mimeType, includeStatusMessage, totalLines);
+            }
+            else {
+                return await this.readFromEndWithReadline(filePath, requestedLines, mimeType, includeStatusMessage, totalLines);
+            }
+        }
+        // For positive offsets
+        else {
+            if (fileSize < FILE_SIZE_LIMITS.LARGE_FILE_THRESHOLD || offset === 0) {
+                return await this.readFromStartWithReadline(filePath, offset, length, mimeType, includeStatusMessage, totalLines);
+            }
+            else {
+                if (offset > READ_PERFORMANCE_THRESHOLDS.DEEP_OFFSET_THRESHOLD) {
+                    return await this.readFromEstimatedPosition(filePath, offset, length, mimeType, includeStatusMessage, totalLines);
+                }
+                else {
+                    return await this.readFromStartWithReadline(filePath, offset, length, mimeType, includeStatusMessage, totalLines);
+                }
+            }
+        }
+    }
+    /**
+     * Read last N lines efficiently by reading file backwards
+     */
+    async readLastNLinesReverse(filePath, n, mimeType, includeStatusMessage = true, fileTotalLines) {
+        const fd = await fs.open(filePath, 'r');
+        try {
+            const stats = await fd.stat();
+            const fileSize = stats.size;
+            let position = fileSize;
+            let lines = [];
+            let partialLine = '';
+            while (position > 0 && lines.length < n) {
+                const readSize = Math.min(READ_PERFORMANCE_THRESHOLDS.CHUNK_SIZE, position);
+                position -= readSize;
+                const buffer = Buffer.alloc(readSize);
+                await fd.read(buffer, 0, readSize, position);
+                const chunk = buffer.toString('utf-8');
+                const text = chunk + partialLine;
+                const chunkLines = text.split('\n');
+                partialLine = chunkLines.shift() || '';
+                lines = chunkLines.concat(lines);
+            }
+            if (position === 0 && partialLine) {
+                lines.unshift(partialLine);
+            }
+            const result = lines.slice(-n);
+            const content = includeStatusMessage
+                ? `${this.generateEnhancedStatusMessage(result.length, -n, fileTotalLines, true)}\n\n${result.join('\n')}`
+                : result.join('\n');
+            return { content, mimeType, metadata: {} };
+        }
+        finally {
+            await fd.close();
+        }
+    }
+    /**
+     * Read from end using readline with circular buffer
+     */
+    async readFromEndWithReadline(filePath, requestedLines, mimeType, includeStatusMessage = true, fileTotalLines) {
+        const rl = createInterface({
+            input: createReadStream(filePath),
+            crlfDelay: Infinity
+        });
+        const buffer = new Array(requestedLines);
+        let bufferIndex = 0;
+        let totalLines = 0;
+        for await (const line of rl) {
+            buffer[bufferIndex] = line;
+            bufferIndex = (bufferIndex + 1) % requestedLines;
+            totalLines++;
+        }
+        rl.close();
+        let result;
+        if (totalLines >= requestedLines) {
+            result = [
+                ...buffer.slice(bufferIndex),
+                ...buffer.slice(0, bufferIndex)
+            ].filter(line => line !== undefined);
+        }
+        else {
+            result = buffer.slice(0, totalLines);
+        }
+        const content = includeStatusMessage
+            ? `${this.generateEnhancedStatusMessage(result.length, -requestedLines, fileTotalLines, true)}\n\n${result.join('\n')}`
+            : result.join('\n');
+        return { content, mimeType, metadata: {} };
+    }
+    /**
+     * Read from start/middle using readline
+     */
+    async readFromStartWithReadline(filePath, offset, length, mimeType, includeStatusMessage = true, fileTotalLines) {
+        const rl = createInterface({
+            input: createReadStream(filePath),
+            crlfDelay: Infinity
+        });
+        const result = [];
+        let lineNumber = 0;
+        for await (const line of rl) {
+            if (lineNumber >= offset && result.length < length) {
+                result.push(line);
+            }
+            if (result.length >= length)
+                break;
+            lineNumber++;
+        }
+        rl.close();
+        if (includeStatusMessage) {
+            const statusMessage = this.generateEnhancedStatusMessage(result.length, offset, fileTotalLines, false);
+            const content = `${statusMessage}\n\n${result.join('\n')}`;
+            return { content, mimeType, metadata: {} };
+        }
+        else {
+            const content = result.join('\n');
+            return { content, mimeType, metadata: {} };
+        }
+    }
+    /**
+     * Read from estimated byte position for very large files
+     */
+    async readFromEstimatedPosition(filePath, offset, length, mimeType, includeStatusMessage = true, fileTotalLines) {
+        // First, do a quick scan to estimate lines per byte
+        const rl = createInterface({
+            input: createReadStream(filePath),
+            crlfDelay: Infinity
+        });
+        let sampleLines = 0;
+        let bytesRead = 0;
+        for await (const line of rl) {
+            bytesRead += Buffer.byteLength(line, 'utf-8') + 1;
+            sampleLines++;
+            if (bytesRead >= READ_PERFORMANCE_THRESHOLDS.SAMPLE_SIZE)
+                break;
+        }
+        rl.close();
+        if (sampleLines === 0) {
+            return await this.readFromStartWithReadline(filePath, offset, length, mimeType, includeStatusMessage, fileTotalLines);
+        }
+        // Estimate position
+        const avgLineLength = bytesRead / sampleLines;
+        const estimatedBytePosition = Math.floor(offset * avgLineLength);
+        const fd = await fs.open(filePath, 'r');
+        try {
+            const stats = await fd.stat();
+            const startPosition = Math.min(estimatedBytePosition, stats.size);
+            const stream = createReadStream(filePath, { start: startPosition });
+            const rl2 = createInterface({
+                input: stream,
+                crlfDelay: Infinity
+            });
+            const result = [];
+            let firstLineSkipped = false;
+            for await (const line of rl2) {
+                if (!firstLineSkipped && startPosition > 0) {
+                    firstLineSkipped = true;
+                    continue;
+                }
+                if (result.length < length) {
+                    result.push(line);
+                }
+                else {
+                    break;
+                }
+            }
+            rl2.close();
+            const content = includeStatusMessage
+                ? `${this.generateEnhancedStatusMessage(result.length, offset, fileTotalLines, false)}\n\n${result.join('\n')}`
+                : result.join('\n');
+            return { content, mimeType, metadata: {} };
+        }
+        finally {
+            await fd.close();
+        }
+    }
+}

package/dist/utils/ripgrep-resolver.js

@@ -31,10 +31,11 @@ export async function getRipgrepPath() {
     catch (e) {
         // @vscode/ripgrep import or binary resolution failed, continue to fallbacks
     }
-    // Strategy 2: Try system ripgrep using 'which' command
+    // Strategy 2: Try system ripgrep using 'which' (Unix) or 'where' (Windows)
     try {
         const systemRg = process.platform === 'win32' ? 'rg.exe' : 'rg';
-        const result = execSync(`which ${systemRg}`, { encoding: 'utf-8' }).trim();
+        const whichCmd = process.platform === 'win32' ? 'where' : 'which';
+        const result = execSync(`${whichCmd} ${systemRg}`, { encoding: 'utf-8' }).trim().split(/\r?\n/)[0];
         if (result && existsSync(result)) {
             cachedRgPath = result;
             return result;

package/dist/utils/system-info.d.ts

@@ -35,6 +35,11 @@ export interface SystemInfo {
         path: string;
         npmVersion?: string;
     };
+    pythonInfo?: {
+        available: boolean;
+        command: string;
+        version?: string;
+    };
     processInfo: {
         pid: number;
         arch: string;