@wonderwhy-er/desktop-commander 0.2.23 → 0.2.25

package/dist/utils/files/image.js

@@ -0,0 +1,78 @@
+/**
+ * Image file handler
+ * Handles reading image files and converting to base64
+ */
+import fs from "fs/promises";
+/**
+ * Image file handler implementation
+ * Supports: PNG, JPEG, GIF, WebP, BMP, SVG
+ */
+export class ImageFileHandler {
+    canHandle(path) {
+        const lowerPath = path.toLowerCase();
+        return ImageFileHandler.IMAGE_EXTENSIONS.some(ext => lowerPath.endsWith(ext));
+    }
+    async read(path, options) {
+        // Images are always read in full, ignoring offset and length
+        const buffer = await fs.readFile(path);
+        const content = buffer.toString('base64');
+        const mimeType = this.getMimeType(path);
+        return {
+            content,
+            mimeType,
+            metadata: {
+                isImage: true
+            }
+        };
+    }
+    async write(path, content) {
+        // If content is base64 string, convert to buffer
+        if (typeof content === 'string') {
+            const buffer = Buffer.from(content, 'base64');
+            await fs.writeFile(path, buffer);
+        }
+        else {
+            await fs.writeFile(path, content);
+        }
+    }
+    async getInfo(path) {
+        const stats = await fs.stat(path);
+        return {
+            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: 'image',
+            metadata: {
+                isImage: true
+            }
+        };
+    }
+    /**
+     * Get MIME type for image based on file extension
+     */
+    getMimeType(path) {
+        const lowerPath = path.toLowerCase();
+        for (const [ext, mimeType] of Object.entries(ImageFileHandler.IMAGE_MIME_TYPES)) {
+            if (lowerPath.endsWith(ext)) {
+                return mimeType;
+            }
+        }
+        return 'application/octet-stream'; // Fallback
+    }
+}
+ImageFileHandler.IMAGE_EXTENSIONS = [
+    '.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp', '.svg'
+];
+ImageFileHandler.IMAGE_MIME_TYPES = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.bmp': 'image/bmp',
+    '.svg': 'image/svg+xml'
+};

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

@@ -0,0 +1,10 @@
+/**
+ * File handling system
+ * Exports all file handlers, interfaces, and utilities
+ */
+export * from './base.js';
+export { getFileHandler, isExcelFile, isImageFile } from './factory.js';
+export { TextFileHandler } from './text.js';
+export { ImageFileHandler } from './image.js';
+export { BinaryFileHandler } from './binary.js';
+export { ExcelFileHandler } from './excel.js';

package/dist/utils/files/index.js

@@ -0,0 +1,13 @@
+/**
+ * File handling system
+ * Exports all file handlers, interfaces, and utilities
+ */
+// Base interfaces and types
+export * from './base.js';
+// Factory function
+export { getFileHandler, isExcelFile, isImageFile } from './factory.js';
+// File handlers
+export { TextFileHandler } from './text.js';
+export { ImageFileHandler } from './image.js';
+export { BinaryFileHandler } from './binary.js';
+export { ExcelFileHandler } from './excel.js';

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;
+}