@wonderwhy-er/desktop-commander 0.1.35 → 0.1.37

package/dist/terminal-manager.js

@@ -1,7 +1,7 @@
 import { spawn } from 'child_process';
 import { DEFAULT_COMMAND_TIMEOUT } from './config.js';
 import { configManager } from './config-manager.js';
-import { capture } from "./utils.js";
+import { capture } from "./utils/capture.js";
 export class TerminalManager {
     constructor() {
         this.sessions = new Map();
@@ -118,7 +118,9 @@ export class TerminalManager {
             return true;
         }
         catch (error) {
-            capture('server_request_error', { error: error, message: `Failed to terminate process ${pid}:` });
+            // Convert error to string, handling both Error objects and other types
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            capture('server_request_error', { error: errorMessage, message: `Failed to terminate process ${pid}:` });
             return false;
         }
     }

package/dist/tools/edit.d.ts

@@ -3,10 +3,12 @@ interface SearchReplace {
     search: string;
     replace: string;
 }
-export declare function performSearchReplace(filePath: string, block: SearchReplace): Promise<ServerResult>;
-export declare function parseEditBlock(blockContent: string): Promise<{
-    filePath: string;
-    searchReplace: SearchReplace;
-    error?: string;
-}>;
+export declare function performSearchReplace(filePath: string, block: SearchReplace, expectedReplacements?: number): Promise<ServerResult>;
+/**
+ * Handle edit_block command with enhanced functionality
+ * - Supports multiple replacements
+ * - Validates expected replacements count
+ * - Provides detailed error messages
+ */
+export declare function handleEditBlock(args: unknown): Promise<ServerResult>;
 export {};

package/dist/tools/edit.js

@@ -1,48 +1,175 @@
 import { readFile, writeFile } from './filesystem.js';
-export async function performSearchReplace(filePath, block) {
-    // Read file as plain string (don't pass true to get just the string)
+import { recursiveFuzzyIndexOf, getSimilarityRatio } from './fuzzySearch.js';
+import { capture } from '../utils/capture.js';
+import { EditBlockArgsSchema } from "./schemas.js";
+import path from 'path';
+/**
+ * Threshold for fuzzy matching - similarity must be at least this value to be considered
+ * (0-1 scale where 1 is perfect match and 0 is completely different)
+ */
+const FUZZY_THRESHOLD = 0.7;
+export async function performSearchReplace(filePath, block, expectedReplacements = 1) {
+    // Check for empty search string to prevent infinite loops
+    if (block.search === "") {
+        return {
+            content: [{
+                    type: "text",
+                    text: "Empty search strings are not allowed. Please provide a non-empty string to search for."
+                }],
+        };
+    }
+    // Get file extension for telemetry using path module
+    const fileExtension = path.extname(filePath).toLowerCase();
+    // Capture file extension in telemetry without capturing the file path
+    capture('server_edit_block', { fileExtension: fileExtension });
+    // Read file as plain string
     const { content } = await readFile(filePath);
     // Make sure content is a string
     if (typeof content !== 'string') {
         throw new Error('Wrong content for file ' + filePath);
     }
-    ;
-    // Find first occurrence
-    const searchIndex = content.indexOf(block.search);
-    if (searchIndex === -1) {
+    // First try exact match
+    let tempContent = content;
+    let count = 0;
+    let pos = tempContent.indexOf(block.search);
+    while (pos !== -1) {
+        count++;
+        pos = tempContent.indexOf(block.search, pos + 1);
+    }
+    // If exact match found and count matches expected replacements, proceed with exact replacement
+    if (count > 0 && count === expectedReplacements) {
+        // Replace all occurrences
+        let newContent = content;
+        // If we're only replacing one occurrence, replace it directly
+        if (expectedReplacements === 1) {
+            const searchIndex = newContent.indexOf(block.search);
+            newContent =
+                newContent.substring(0, searchIndex) +
+                    block.replace +
+                    newContent.substring(searchIndex + block.search.length);
+        }
+        else {
+            // Replace all occurrences using split and join for multiple replacements
+            newContent = newContent.split(block.search).join(block.replace);
+        }
+        await writeFile(filePath, newContent);
         return {
-            content: [{ type: "text", text: `Search content not found in ${filePath}.` }],
+            content: [{
+                    type: "text",
+                    text: `Successfully applied ${expectedReplacements} edit${expectedReplacements > 1 ? 's' : ''} to ${filePath}`
+                }],
         };
     }
-    // Replace content
-    const newContent = content.substring(0, searchIndex) +
-        block.replace +
-        content.substring(searchIndex + block.search.length);
-    await writeFile(filePath, newContent);
-    return {
-        content: [{ type: "text", text: `Successfully applied edit to ${filePath}` }],
-    };
-}
-export async function parseEditBlock(blockContent) {
-    const lines = blockContent.split('\n');
-    // First line should be the file path
-    const filePath = lines[0].trim();
-    // Find the markers
-    const searchStart = lines.indexOf('<<<<<<< SEARCH');
-    const divider = lines.indexOf('=======');
-    const replaceEnd = lines.indexOf('>>>>>>> REPLACE');
-    if (searchStart === -1 || divider === -1 || replaceEnd === -1) {
+    // If exact match found but count doesn't match expected, inform the user
+    if (count > 0 && count !== expectedReplacements) {
         return {
-            filePath: '',
-            searchReplace: { search: '', replace: '' },
-            error: 'Invalid edit block format - missing markers'
+            content: [{
+                    type: "text",
+                    text: `Expected ${expectedReplacements} occurrences but found ${count} in ${filePath}. ` +
+                        `Double check and make sure you understand all occurencies and if you want to replace all ${count} occurrences, set expected_replacements to ${count}. ` +
+                        `If there are many occurrancies and you want to change some of them and keep the rest. Do it one by one, by adding more lines around each occurrence.` +
+                        `If you want to replace a specific occurrence, make your search string more unique by adding more lines around search string.`
+                }],
         };
     }
-    // Extract search and replace content
-    const search = lines.slice(searchStart + 1, divider).join('\n');
-    const replace = lines.slice(divider + 1, replaceEnd).join('\n');
-    return {
-        filePath,
-        searchReplace: { search, replace }
+    // If exact match not found, try fuzzy search
+    if (count === 0) {
+        // Track fuzzy search time
+        const startTime = performance.now();
+        // Perform fuzzy search
+        const fuzzyResult = recursiveFuzzyIndexOf(content, block.search);
+        const similarity = getSimilarityRatio(block.search, fuzzyResult.value);
+        // Calculate execution time in milliseconds
+        const executionTime = performance.now() - startTime;
+        // Check if the fuzzy match is "close enough"
+        if (similarity >= FUZZY_THRESHOLD) {
+            // Format differences for clearer output
+            const diff = highlightDifferences(block.search, fuzzyResult.value);
+            // Capture the fuzzy search event
+            capture('server_fuzzy_search_performed', {
+                similarity: similarity,
+                execution_time_ms: executionTime,
+                search_length: block.search.length,
+                file_size: content.length,
+                threshold: FUZZY_THRESHOLD,
+                found_text_length: fuzzyResult.value.length
+            });
+            // If we allow fuzzy matches, we would make the replacement here
+            // For now, we'll return a detailed message about the fuzzy match
+            return {
+                content: [{
+                        type: "text",
+                        text: `Exact match not found, but found a similar text with ${Math.round(similarity * 100)}% similarity (found in ${executionTime.toFixed(2)}ms):\n\n` +
+                            `Differences:\n${diff}\n\n` +
+                            `To replace this text, use the exact text found in the file.`
+                    }],
+            };
+        }
+        else {
+            // If the fuzzy match isn't close enough
+            // Still capture the fuzzy search event even for unsuccessful matches
+            capture('server_fuzzy_search_performed', {
+                similarity: similarity,
+                execution_time_ms: executionTime,
+                search_length: block.search.length,
+                file_size: content.length,
+                threshold: FUZZY_THRESHOLD,
+                found_text_length: fuzzyResult.value.length,
+                below_threshold: true
+            });
+            return {
+                content: [{
+                        type: "text",
+                        text: `Search content not found in ${filePath}. The closest match was "${fuzzyResult.value}" ` +
+                            `with only ${Math.round(similarity * 100)}% similarity, which is below the ${Math.round(FUZZY_THRESHOLD * 100)}% threshold. ` +
+                            `(Fuzzy search completed in ${executionTime.toFixed(2)}ms)`
+                    }],
+            };
+        }
+    }
+    throw new Error("Unexpected error during search and replace operation.");
+}
+/**
+ * Generates a character-level diff using standard {-removed-}{+added+} format
+ * @param expected The string that was searched for
+ * @param actual The string that was found
+ * @returns A formatted string showing character-level differences
+ */
+function highlightDifferences(expected, actual) {
+    // Implementation of a simplified character-level diff
+    // Find common prefix and suffix
+    let prefixLength = 0;
+    const minLength = Math.min(expected.length, actual.length);
+    // Determine common prefix length
+    while (prefixLength < minLength &&
+        expected[prefixLength] === actual[prefixLength]) {
+        prefixLength++;
+    }
+    // Determine common suffix length
+    let suffixLength = 0;
+    while (suffixLength < minLength - prefixLength &&
+        expected[expected.length - 1 - suffixLength] === actual[actual.length - 1 - suffixLength]) {
+        suffixLength++;
+    }
+    // Extract the common and different parts
+    const commonPrefix = expected.substring(0, prefixLength);
+    const commonSuffix = expected.substring(expected.length - suffixLength);
+    const expectedDiff = expected.substring(prefixLength, expected.length - suffixLength);
+    const actualDiff = actual.substring(prefixLength, actual.length - suffixLength);
+    // Format the output as a character-level diff
+    return `${commonPrefix}{-${expectedDiff}-}{+${actualDiff}+}${commonSuffix}`;
+}
+/**
+ * Handle edit_block command with enhanced functionality
+ * - Supports multiple replacements
+ * - Validates expected replacements count
+ * - Provides detailed error messages
+ */
+export async function handleEditBlock(args) {
+    const parsed = EditBlockArgsSchema.parse(args);
+    const searchReplace = {
+        search: parsed.old_string,
+        replace: parsed.new_string
     };
+    return performSearchReplace(parsed.file_path, searchReplace, parsed.expected_replacements);
 }

package/dist/tools/execute.js

@@ -1,7 +1,7 @@
 import { terminalManager } from '../terminal-manager.js';
 import { commandManager } from '../command-manager.js';
 import { ExecuteCommandArgsSchema, ReadOutputArgsSchema, ForceTerminateArgsSchema } from './schemas.js';
-import { capture } from "../utils.js";
+import { capture } from "../utils/capture.js";
 export async function executeCommand(args) {
     const parsed = ExecuteCommandArgsSchema.safeParse(args);
     if (!parsed.success) {
@@ -13,7 +13,7 @@ export async function executeCommand(args) {
     }
     try {
         // Extract all commands for analytics while ensuring execution continues even if parsing fails
-        const commands = commandManager.extractCommands(parsed.data.command);
+        const commands = commandManager.extractCommands(parsed.data.command).join(', ');
         capture('server_execute_command', {
             command: commandManager.getBaseCommand(parsed.data.command), // Keep original for backward compatibility
             commands: commands // Add the array of all identified commands

package/dist/tools/filesystem.js

@@ -2,7 +2,8 @@ import fs from "fs/promises";
 import path from "path";
 import os from 'os';
 import fetch from 'cross-fetch';
-import { capture, withTimeout } from '../utils.js';
+import { capture } from '../utils/capture.js';
+import { withTimeout } from '../utils/withTimeout.js';
 import { configManager } from '../config-manager.js';
 // Initialize allowed directories from configuration
 async function getAllowedDirs() {
@@ -123,7 +124,11 @@ export async function validatePath(requestedPath) {
             : path.resolve(process.cwd(), expandedPath);
         // Check if path is allowed
         if (!(await isPathAllowed(absolute))) {
-            throw (`Path not allowed: ${requestedPath}. Must be within one of these directories: ${(await getAllowedDirs()).join(', ')}`);
+            capture('server_path_validation_error', {
+                error: 'Path not allowed',
+                allowedDirsCount: (await getAllowedDirs()).length
+            });
+            throw new Error(`Path not allowed: ${requestedPath}. Must be within one of these directories: ${(await getAllowedDirs()).join(', ')}`);
         }
         // Check if path exists
         try {
@@ -143,9 +148,13 @@ export async function validatePath(requestedPath) {
         }
     };
     // Execute with timeout
-    const result = await withTimeout(validationOperation(), PATH_VALIDATION_TIMEOUT, `Path validation for ${requestedPath}`, null);
+    const result = await withTimeout(validationOperation(), PATH_VALIDATION_TIMEOUT, `Path validation operation`, // Generic name for telemetry
+    null);
     if (result === null) {
-        // Return a path with an error indicator instead of throwing
+        // Keep original path in error for AI but a generic message for telemetry
+        capture('server_path_validation_timeout', {
+            timeoutMs: PATH_VALIDATION_TIMEOUT
+        });
         throw new Error(`Path validation failed for path: ${requestedPath}`);
     }
     return result;
@@ -206,22 +215,29 @@ export async function readFileFromDisk(filePath) {
     // Import the MIME type utilities
     const { getMimeType, isImageFile } = await import('./mime-types.js');
     const validPath = await validatePath(filePath);
+    // Get file extension for telemetry using path module consistently
+    const fileExtension = path.extname(validPath).toLowerCase();
     // Check file size before attempting to read
     try {
         const stats = await fs.stat(validPath);
         const MAX_SIZE = 100 * 1024; // 100KB limit
         if (stats.size > MAX_SIZE) {
             const message = `File too large (${(stats.size / 1024).toFixed(2)}KB > ${MAX_SIZE / 1024}KB limit)`;
+            // Capture file extension in telemetry without capturing the file path
+            capture('server_read_file_large', { fileExtension: fileExtension });
             return {
                 content: message,
                 mimeType: 'text/plain',
                 isImage: false
             };
         }
+        // Capture file extension in telemetry without capturing the file path
+        capture('server_read_file', { fileExtension: fileExtension });
     }
     catch (error) {
         console.error('error catch ' + error);
-        capture('server_read_file_error', { error: error });
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        capture('server_read_file_error', { error: errorMessage, fileExtension: fileExtension });
         // If we can't stat the file, continue anyway and let the read operation handle errors
         //console.error(`Failed to stat file ${validPath}:`, error);
     }
@@ -273,6 +289,10 @@ export async function readFile(filePath, isUrl) {
 }
 export async function writeFile(filePath, content) {
     const validPath = await validatePath(filePath);
+    // Get file extension for telemetry
+    const fileExtension = path.extname(validPath).toLowerCase();
+    // Capture file extension in telemetry without capturing the file path
+    capture('server_write_file', { fileExtension: fileExtension });
     await fs.writeFile(validPath, content, "utf-8");
 }
 export async function readMultipleFiles(paths) {
@@ -313,7 +333,19 @@ export async function moveFile(sourcePath, destinationPath) {
 export async function searchFiles(rootPath, pattern) {
     const results = [];
     async function search(currentPath) {
-        const entries = await fs.readdir(currentPath, { withFileTypes: true });
+        let entries;
+        try {
+            entries = await fs.readdir(currentPath, { withFileTypes: true });
+        }
+        catch (error) {
+            // Only sanitize for telemetry, not for the returned error
+            capture('server_search_files_error', {
+                errorType: error instanceof Error ? error.name : 'Unknown',
+                errorMessage: 'Error reading directory',
+                isReadDirError: true
+            });
+            return; // Skip this directory on error
+        }
         for (const entry of entries) {
             const fullPath = path.join(currentPath, entry.name);
             try {
@@ -330,10 +362,27 @@ export async function searchFiles(rootPath, pattern) {
             }
         }
     }
-    // if path not exist, it will throw an error
-    const validPath = await validatePath(rootPath);
-    await search(validPath);
-    return results;
+    try {
+        // Validate root path before starting search
+        const validPath = await validatePath(rootPath);
+        await search(validPath);
+        // Log only the count of found files, not their paths
+        capture('server_search_files_complete', {
+            resultsCount: results.length,
+            patternLength: pattern.length
+        });
+        return results;
+    }
+    catch (error) {
+        // For telemetry only - sanitize error info
+        capture('server_search_files_error', {
+            errorType: error instanceof Error ? error.name : 'Unknown',
+            errorMessage: 'Error with root path',
+            isRootPathError: true
+        });
+        // Re-throw the original error for the caller
+        throw error;
+    }
 }
 export async function getFileInfo(filePath) {
     const validPath = await validatePath(filePath);

package/dist/tools/fuzzySearch.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Recursively finds the closest match to a query string within text using fuzzy matching
+ * @param text The text to search within
+ * @param query The query string to find
+ * @param start Start index in the text (default: 0)
+ * @param end End index in the text (default: text.length)
+ * @param parentDistance Best distance found so far (default: Infinity)
+ * @returns Object with start and end indices, matched value, and Levenshtein distance
+ */
+export declare function recursiveFuzzyIndexOf(text: string, query: string, start?: number, end?: number | null, parentDistance?: number, depth?: number): {
+    start: number;
+    end: number;
+    value: string;
+    distance: number;
+};
+/**
+ * Calculates the similarity ratio between two strings
+ * @param a First string
+ * @param b Second string
+ * @returns Similarity ratio (0-1)
+ */
+export declare function getSimilarityRatio(a: string, b: string): number;

package/dist/tools/fuzzySearch.js

@@ -0,0 +1,113 @@
+import { distance } from 'fastest-levenshtein';
+import { capture } from '../utils/capture.js';
+/**
+ * Recursively finds the closest match to a query string within text using fuzzy matching
+ * @param text The text to search within
+ * @param query The query string to find
+ * @param start Start index in the text (default: 0)
+ * @param end End index in the text (default: text.length)
+ * @param parentDistance Best distance found so far (default: Infinity)
+ * @returns Object with start and end indices, matched value, and Levenshtein distance
+ */
+export function recursiveFuzzyIndexOf(text, query, start = 0, end = null, parentDistance = Infinity, depth = 0) {
+    // For debugging and performance tracking purposes
+    if (depth === 0) {
+        const startTime = performance.now();
+        const result = recursiveFuzzyIndexOf(text, query, start, end, parentDistance, depth + 1);
+        const executionTime = performance.now() - startTime;
+        // Capture detailed metrics for the recursive search for in-depth analysis
+        capture('fuzzy_search_recursive_metrics', {
+            execution_time_ms: executionTime,
+            text_length: text.length,
+            query_length: query.length,
+            result_distance: result.distance
+        });
+        return result;
+    }
+    if (end === null)
+        end = text.length;
+    // For small text segments, use iterative approach
+    if (end - start <= 2 * query.length) {
+        return iterativeReduction(text, query, start, end, parentDistance);
+    }
+    let midPoint = start + Math.floor((end - start) / 2);
+    let leftEnd = Math.min(end, midPoint + query.length); // Include query length to cover overlaps
+    let rightStart = Math.max(start, midPoint - query.length); // Include query length to cover overlaps
+    // Calculate distance for current segments
+    let leftDistance = distance(text.substring(start, leftEnd), query);
+    let rightDistance = distance(text.substring(rightStart, end), query);
+    let bestDistance = Math.min(leftDistance, parentDistance, rightDistance);
+    // If parent distance is already the best, use iterative approach
+    if (parentDistance === bestDistance) {
+        return iterativeReduction(text, query, start, end, parentDistance);
+    }
+    // Recursively search the better half
+    if (leftDistance < rightDistance) {
+        return recursiveFuzzyIndexOf(text, query, start, leftEnd, bestDistance, depth + 1);
+    }
+    else {
+        return recursiveFuzzyIndexOf(text, query, rightStart, end, bestDistance, depth + 1);
+    }
+}
+/**
+ * Iteratively refines the best match by reducing the search area
+ * @param text The text to search within
+ * @param query The query string to find
+ * @param start Start index in the text
+ * @param end End index in the text
+ * @param parentDistance Best distance found so far
+ * @returns Object with start and end indices, matched value, and Levenshtein distance
+ */
+function iterativeReduction(text, query, start, end, parentDistance) {
+    const startTime = performance.now();
+    let iterations = 0;
+    let bestDistance = parentDistance;
+    let bestStart = start;
+    let bestEnd = end;
+    // Improve start position
+    let nextDistance = distance(text.substring(bestStart + 1, bestEnd), query);
+    while (nextDistance < bestDistance) {
+        bestDistance = nextDistance;
+        bestStart++;
+        const smallerString = text.substring(bestStart + 1, bestEnd);
+        nextDistance = distance(smallerString, query);
+        iterations++;
+    }
+    // Improve end position
+    nextDistance = distance(text.substring(bestStart, bestEnd - 1), query);
+    while (nextDistance < bestDistance) {
+        bestDistance = nextDistance;
+        bestEnd--;
+        const smallerString = text.substring(bestStart, bestEnd - 1);
+        nextDistance = distance(smallerString, query);
+        iterations++;
+    }
+    const executionTime = performance.now() - startTime;
+    // Capture metrics for the iterative refinement phase
+    capture('fuzzy_search_iterative_metrics', {
+        execution_time_ms: executionTime,
+        iterations: iterations,
+        segment_length: end - start,
+        query_length: query.length,
+        final_distance: bestDistance
+    });
+    return {
+        start: bestStart,
+        end: bestEnd,
+        value: text.substring(bestStart, bestEnd),
+        distance: bestDistance
+    };
+}
+/**
+ * Calculates the similarity ratio between two strings
+ * @param a First string
+ * @param b Second string
+ * @returns Similarity ratio (0-1)
+ */
+export function getSimilarityRatio(a, b) {
+    const maxLength = Math.max(a.length, b.length);
+    if (maxLength === 0)
+        return 1; // Both strings are empty
+    const levenshteinDistance = distance(a, b);
+    return 1 - (levenshteinDistance / maxLength);
+}

package/dist/tools/pdf-reader.d.ts

@@ -0,0 +1,13 @@
+import { FileResult } from './filesystem.js';
+export declare enum PDFOutputFormat {
+    TEXT = "text",
+    MARKDOWN = "markdown",
+    HTML = "html"
+}
+/**
+ * Reads a PDF file and returns its content in the specified format
+ * @param filePath Path to the PDF file
+ * @param outputFormat Desired output format (text, markdown, or html)
+ * @returns FileResult object with the parsed content
+ */
+export declare function readPDFFile(filePath: string, outputFormat?: PDFOutputFormat): Promise<FileResult>;