@wonderwhy-er/desktop-commander 0.2.23 → 0.2.25

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/open-browser.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Open a URL in the default browser (cross-platform)
+ * Uses execFile/spawn with args array to avoid shell injection
+ */
+export declare function openBrowser(url: string): Promise<void>;
+/**
+ * Open the Desktop Commander welcome page
+ */
+export declare function openWelcomePage(): Promise<void>;

package/dist/utils/open-browser.js

@@ -0,0 +1,43 @@
+import { execFile, spawn } from 'child_process';
+import os from 'os';
+import { logToStderr } from './logger.js';
+/**
+ * Open a URL in the default browser (cross-platform)
+ * Uses execFile/spawn with args array to avoid shell injection
+ */
+export async function openBrowser(url) {
+    const platform = os.platform();
+    return new Promise((resolve, reject) => {
+        const callback = (error) => {
+            if (error) {
+                logToStderr('error', `Failed to open browser: ${error.message}`);
+                reject(error);
+            }
+            else {
+                logToStderr('info', `Opened browser to: ${url}`);
+                resolve();
+            }
+        };
+        switch (platform) {
+            case 'darwin':
+                execFile('open', [url], callback);
+                break;
+            case 'win32':
+                // Windows 'start' is a shell builtin, use spawn with shell but pass URL as separate arg
+                spawn('cmd', ['/c', 'start', '', url], { shell: false }).on('close', (code) => {
+                    code === 0 ? resolve() : reject(new Error(`Exit code ${code}`));
+                });
+                break;
+            default:
+                execFile('xdg-open', [url], callback);
+                break;
+        }
+    });
+}
+/**
+ * Open the Desktop Commander welcome page
+ */
+export async function openWelcomePage() {
+    const url = 'https://desktopcommander.app/welcome/';
+    await openBrowser(url);
+}

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;

package/dist/utils/system-info.js

@@ -1,6 +1,7 @@
 import os from 'os';
 import fs from 'fs';
 import path from 'path';
+import { execSync } from 'child_process';
 /**
  * Detect container environment and type
  */
@@ -114,17 +115,51 @@ function discoverContainerMounts(isContainer) {
         try {
             const mountsContent = fs.readFileSync('/proc/mounts', 'utf8');
             const mountLines = mountsContent.split('\n');
+            // System filesystem types that are never user mounts
+            const systemFsTypes = new Set([
+                'overlay', 'tmpfs', 'proc', 'sysfs', 'devpts', 'cgroup', 'cgroup2',
+                'mqueue', 'debugfs', 'securityfs', 'pstore', 'configfs', 'fusectl',
+                'hugetlbfs', 'autofs', 'devtmpfs', 'bpf', 'tracefs', 'shm'
+            ]);
+            // Filesystem types that indicate host mounts
+            const hostMountFsTypes = new Set(['fakeowner', '9p', 'virtiofs', 'fuse.sshfs']);
             for (const line of mountLines) {
                 const parts = line.split(' ');
                 if (parts.length >= 4) {
                     const device = parts[0];
                     const mountPoint = parts[1];
+                    const fsType = parts[2];
                     const options = parts[3];
-                    // Look for user mounts (skip system mounts)
-                    if (mountPoint.startsWith('/mnt/') ||
+                    // Skip system mount points
+                    const isSystemMountPoint = mountPoint === '/' ||
+                        mountPoint.startsWith('/dev') ||
+                        mountPoint.startsWith('/sys') ||
+                        mountPoint.startsWith('/proc') ||
+                        mountPoint.startsWith('/run') ||
+                        mountPoint.startsWith('/sbin') ||
+                        mountPoint === '/etc/resolv.conf' ||
+                        mountPoint === '/etc/hostname' ||
+                        mountPoint === '/etc/hosts';
+                    if (isSystemMountPoint) {
+                        continue;
+                    }
+                    // Detect user mounts by:
+                    // 1. Known host-mount filesystem types (fakeowner, 9p, virtiofs)
+                    // 2. Device from /run/host_mark/ (docker-mcp-gateway pattern)
+                    // 3. Non-system filesystem type with user-like mount point
+                    const isHostMountFs = hostMountFsTypes.has(fsType);
+                    const isHostMarkDevice = device.startsWith('/run/host_mark/');
+                    const isNonSystemFs = !systemFsTypes.has(fsType);
+                    const isUserLikePath = mountPoint.startsWith('/mnt/') ||
                         mountPoint.startsWith('/workspace') ||
                         mountPoint.startsWith('/data/') ||
-                        (mountPoint.startsWith('/home/') && !mountPoint.startsWith('/home/root'))) {
+                        mountPoint.startsWith('/home/') ||
+                        mountPoint.startsWith('/Users/') ||
+                        mountPoint.startsWith('/app/') ||
+                        mountPoint.startsWith('/project/') ||
+                        mountPoint.startsWith('/src/') ||
+                        mountPoint.startsWith('/code/');
+                    if (isHostMountFs || isHostMarkDevice || (isNonSystemFs && isUserLikePath)) {
                         const isReadOnly = options.includes('ro');
                         mounts.push({
                             hostPath: device,
@@ -326,6 +361,36 @@ function detectNodeInfo() {
         return undefined;
     }
 }
+/**
+ * Detect Python installation and version and put on systeminfo.pythonInfo
+ */
+function detectPythonInfo() {
+    // Try python commands in order of preference
+    const pythonCommands = process.platform === 'win32'
+        ? ['python', 'python3', 'py'] // Windows: 'python' is common, 'py' launcher
+        : ['python3', 'python']; // Unix: prefer python3
+    for (const cmd of pythonCommands) {
+        try {
+            const version = execSync(`${cmd} --version`, {
+                encoding: 'utf8',
+                timeout: 5000,
+                stdio: ['pipe', 'pipe', 'pipe']
+            }).trim();
+            // Verify it's Python 3.x
+            if (version.includes('Python 3')) {
+                return {
+                    available: true,
+                    command: cmd,
+                    version: version.replace('Python ', '')
+                };
+            }
+        }
+        catch {
+            // Command not found or failed, try next
+        }
+    }
+    return { available: false, command: '' };
+}
 /**
  * Get comprehensive system information for tool prompts
  */
@@ -420,6 +485,8 @@ export function getSystemInfo() {
     }
     // Detect Node.js installation from current process
     const nodeInfo = detectNodeInfo();
+    // Detect Python installation
+    const pythonInfo = detectPythonInfo();
     // Get process information
     const processInfo = {
         pid: process.pid,
@@ -447,6 +514,7 @@ export function getSystemInfo() {
         },
         isDXT: !!process.env.MCP_DXT,
         nodeInfo,
+        pythonInfo,
         processInfo,
         examplePaths
     };

package/dist/utils/usageTracker.js

@@ -325,6 +325,12 @@ class UsageTracker {
      * Check if user should see onboarding invitation - SIMPLE VERSION
      */
     async shouldShowOnboarding() {
+        // Check feature flag first (remote kill switch)
+        const { featureFlagManager } = await import('./feature-flags.js');
+        const onboardingEnabled = featureFlagManager.get('onboarding_injection', true);
+        if (!onboardingEnabled) {
+            return false;
+        }
         // Check if onboarding is disabled via command line argument
         if (global.disableOnboarding) {
             return false;

package/dist/utils/welcome-onboarding.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Handle welcome page display for new users (A/B test controlled)
+ *
+ * Only shows to:
+ * 1. New users (first run - config was just created)
+ * 2. Users in the 'showOnboardingPage' A/B variant
+ * 3. Haven't seen it yet
+ */
+export declare function handleWelcomePageOnboarding(): Promise<void>;

package/dist/utils/welcome-onboarding.js

@@ -0,0 +1,37 @@
+import { configManager } from '../config-manager.js';
+import { hasFeature } from './ab-test.js';
+import { openWelcomePage } from './open-browser.js';
+import { logToStderr } from './logger.js';
+/**
+ * Handle welcome page display for new users (A/B test controlled)
+ *
+ * Only shows to:
+ * 1. New users (first run - config was just created)
+ * 2. Users in the 'showOnboardingPage' A/B variant
+ * 3. Haven't seen it yet
+ */
+export async function handleWelcomePageOnboarding() {
+    // Only for brand new users (config just created)
+    if (!configManager.isFirstRun()) {
+        return;
+    }
+    // Check A/B test assignment
+    const shouldShow = await hasFeature('showOnboardingPage');
+    if (!shouldShow) {
+        logToStderr('debug', 'Welcome page skipped (A/B: noOnboardingPage)');
+        return;
+    }
+    // Double-check not already shown (safety)
+    const alreadyShown = await configManager.getValue('sawOnboardingPage');
+    if (alreadyShown) {
+        return;
+    }
+    try {
+        await openWelcomePage();
+        await configManager.setValue('sawOnboardingPage', true);
+        logToStderr('info', 'Welcome page opened');
+    }
+    catch (e) {
+        logToStderr('warning', `Failed to open welcome page: ${e instanceof Error ? e.message : e}`);
+    }
+}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.2.23";
+export declare const VERSION = "0.2.25";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.2.23';
+export const VERSION = '0.2.25';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wonderwhy-er/desktop-commander",
-  "version": "0.2.23",
+  "version": "0.2.25",
   "description": "MCP server for terminal operations and file editing",
   "mcpName": "io.github.wonderwhy-er/desktop-commander",
   "license": "MIT",
@@ -22,7 +22,7 @@
     "testemonials"
   ],
   "scripts": {
-    "postinstall": "node dist/track-installation.js && node dist/npm-scripts/verify-ripgrep.js || true",
+    "postinstall": "node dist/track-installation.js && node dist/npm-scripts/verify-ripgrep.js || node -e \"process.exit(0)\"",
     "open-chat": "open -n /Applications/Claude.app",
     "sync-version": "node scripts/sync-version.js",
     "bump": "node scripts/sync-version.js --bump",
@@ -32,7 +32,7 @@
     "watch": "tsc --watch",
     "start": "node dist/index.js",
     "start:debug": "node --inspect-brk=9229 dist/index.js",
-    "setup": "npm install && npm run build && node setup-claude-server.js",
+    "setup": "npm install --include=dev && npm run build && node setup-claude-server.js",
     "setup:debug": "npm install && npm run build && node setup-claude-server.js --debug",
     "remove": "npm install && npm run build && node uninstall-claude-server.js",
     "prepare": "npm run build",
@@ -78,11 +78,22 @@
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.9.0",
+    "@opendocsg/pdf2md": "^0.2.2",
     "@vscode/ripgrep": "^1.15.9",
     "cross-fetch": "^4.1.0",
+    "exceljs": "^4.4.0",
     "fastest-levenshtein": "^1.0.16",
+    "file-type": "^21.1.1",
     "glob": "^10.3.10",
     "isbinaryfile": "^5.0.4",
+    "md-to-pdf": "^5.2.5",
+    "pdf-lib": "^1.17.1",
+    "remark": "^15.0.1",
+    "remark-gfm": "^4.0.1",
+    "remark-parse": "^11.0.0",
+    "sharp": "^0.34.5",
+    "unified": "^11.0.5",
+    "unpdf": "^1.4.0",
     "zod": "^3.24.1",
     "zod-to-json-schema": "^3.23.5"
   },