@wonderwhy-er/desktop-commander 0.1.39 → 0.2.0

package/README.md

@@ -58,6 +58,10 @@ Execute long-running terminal commands on your computer and manage processes thr
   - Multiple file support
   - Pattern-based replacements
   - vscode-ripgrep based recursive code or text search in folders
+- Comprehensive audit logging:
+  - All tool calls are automatically logged
+  - Log rotation with 10MB size limit
+  - Detailed timestamps and arguments
 
 ## Installation
 First, ensure you've downloaded and installed the [Claude Desktop app](https://claude.ai/download) and you have [npm installed](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm).
@@ -140,24 +144,24 @@ The server provides a comprehensive set of tools organized into several categori
 
 | Category | Tool | Description |
 |----------|------|-------------|
-| **Configuration** | `get_config` | Get the complete server configuration as JSON (includes blockedCommands, defaultShell, allowedDirectories) |
-| | `set_config_value` | Set a specific configuration value by key. Available settings: <br>• `blockedCommands`: Array of shell commands that cannot be executed<br>• `defaultShell`: Shell to use for commands (e.g., bash, zsh, powershell)<br>• `allowedDirectories`: Array of filesystem paths the server can access for file operations (⚠️ terminal commands can still access files outside these directories) |
+| **Configuration** | `get_config` | Get the complete server configuration as JSON (includes blockedCommands, defaultShell, allowedDirectories, fileReadLineLimit, fileWriteLineLimit, telemetryEnabled) |
+| | `set_config_value` | Set a specific configuration value by key. Available settings: <br>• `blockedCommands`: Array of shell commands that cannot be executed<br>• `defaultShell`: Shell to use for commands (e.g., bash, zsh, powershell)<br>• `allowedDirectories`: Array of filesystem paths the server can access for file operations (⚠️ terminal commands can still access files outside these directories)<br>• `fileReadLineLimit`: Maximum lines to read at once (default: 1000)<br>• `fileWriteLineLimit`: Maximum lines to write at once (default: 50)<br>• `telemetryEnabled`: Enable/disable telemetry (boolean) |
 | **Terminal** | `execute_command` | Execute a terminal command with configurable timeout and shell selection |
 | | `read_output` | Read new output from a running terminal session |
 | | `force_terminate` | Force terminate a running terminal session |
 | | `list_sessions` | List all active terminal sessions |
 | | `list_processes` | List all running processes with detailed information |
 | | `kill_process` | Terminate a running process by PID |
-| **Filesystem** | `read_file` | Read contents from local filesystem or URLs (supports text and images) |
+| **Filesystem** | `read_file` | Read contents from local filesystem or URLs with line-based pagination (supports offset and length parameters) |
 | | `read_multiple_files` | Read multiple files simultaneously |
-| | `write_file` | Completely replace file contents (best for large changes) |
+| | `write_file` | Write file contents with options for rewrite or append mode (uses configurable line limits) |
 | | `create_directory` | Create a new directory or ensure it exists |
 | | `list_directory` | Get detailed listing of files and directories |
 | | `move_file` | Move or rename files and directories |
 | | `search_files` | Find files by name using case-insensitive substring matching |
 | | `search_code` | Search for text/code patterns within file contents using ripgrep |
 | | `get_file_info` | Retrieve detailed metadata about a file or directory |
-| **Text Editing** | `edit_block` | Apply surgical text replacements (best for changes <20% of file size) |
+| **Text Editing** | `edit_block` | Apply targeted text replacements with enhanced prompting for smaller edits (includes character-level diff feedback) |
 
 ### Tool Usage Examples
 
@@ -181,6 +185,18 @@ console.log("new message");
 >>>>>>> REPLACE
 ```
 
+### Enhanced Edit Block Features
+
+The `edit_block` tool includes several enhancements for better reliability:
+
+1. **Improved Prompting**: Tool descriptions now emphasize making multiple small, focused edits rather than one large change
+2. **Fuzzy Search Fallback**: When exact matches fail, it performs fuzzy search and provides detailed feedback
+3. **Character-level Diffs**: Shows exactly what's different using `{-removed-}{+added+}` format
+4. **Multiple Occurrence Support**: Can replace multiple instances with `expected_replacements` parameter
+5. **Comprehensive Logging**: All fuzzy searches are logged for analysis and debugging
+
+When a search fails, you'll see detailed information about the closest match found, including similarity percentage, execution time, and character differences. All these details are automatically logged for later analysis using the fuzzy search log tools.
+
 ### URL Support
 - `read_file` can now fetch content from both local files and URLs
 - Example: `read_file` with `isUrl: true` parameter to read from web resources
@@ -189,6 +205,69 @@ console.log("new message");
 - Claude can see and analyze the actual image content
 - Default 30-second timeout for URL requests
 
+## Fuzzy Search Log Analysis (npm scripts)
+
+The fuzzy search logging system includes convenient npm scripts for analyzing logs outside of the MCP environment:
+
+```bash
+# View recent fuzzy search logs
+npm run logs:view -- --count 20
+
+# Analyze patterns and performance
+npm run logs:analyze -- --threshold 0.8
+
+# Export logs to CSV or JSON
+npm run logs:export -- --format json --output analysis.json
+
+# Clear all logs (with confirmation)
+npm run logs:clear
+```
+
+For detailed documentation on these scripts, see [scripts/README.md](scripts/README.md).
+
+## Fuzzy Search Logs
+
+Desktop Commander includes comprehensive logging for fuzzy search operations in the `edit_block` tool. When an exact match isn't found, the system performs a fuzzy search and logs detailed information for analysis.
+
+### What Gets Logged
+
+Every fuzzy search operation logs:
+- **Search and found text**: The text you're looking for vs. what was found
+- **Similarity score**: How close the match is (0-100%)
+- **Execution time**: How long the search took
+- **Character differences**: Detailed diff showing exactly what's different
+- **File metadata**: Extension, search/found text lengths
+- **Character codes**: Specific character codes causing differences
+
+### Log Location
+
+Logs are automatically saved to:
+- **macOS/Linux**: `~/.claude-server-commander-logs/fuzzy-search.log`
+- **Windows**: `%USERPROFILE%\.claude-server-commander-logs\fuzzy-search.log`
+
+### What You'll Learn
+
+The fuzzy search logs help you understand:
+1. **Why exact matches fail**: Common issues like whitespace differences, line endings, or character encoding
+2. **Performance patterns**: How search complexity affects execution time
+3. **File type issues**: Which file extensions commonly have matching problems
+4. **Character encoding problems**: Specific character codes that cause diffs
+
+## Audit Logging
+
+Desktop Commander now includes comprehensive logging for all tool calls:
+
+### What Gets Logged
+- Every tool call is logged with timestamp, tool name, and arguments (sanitized for privacy)
+- Logs are rotated automatically when they reach 10MB in size
+
+### Log Location
+Logs are saved to:
+- **macOS/Linux**: `~/.claude-server-commander/claude_tool_call.log`
+- **Windows**: `%USERPROFILE%\.claude-server-commander\claude_tool_call.log`
+
+This audit trail helps with debugging, security monitoring, and understanding how Claude is interacting with your system.
+
 ## Handling Long-Running Commands
 
 For commands that may take a while:
@@ -297,6 +376,8 @@ This project extends the MCP Filesystem Server to enable:
 Created as part of exploring Claude MCPs: https://youtube.com/live/TlbjFDbl5Us
 
 ## DONE
+- **20-05-2025 v0.1.40 Release** - Added audit logging for all tool calls, improved line-based file operations, enhanced edit_block with better prompting for smaller edits, added explicit telemetry opt-out prompting 
+- **05-05-2025 Fuzzy Search Logging** - Added comprehensive logging system for fuzzy search operations with detailed analysis tools, character-level diffs, and performance metrics to help debug edit_block failures
 - **29-04-2025 Telemetry Opt Out through configuration** - There is now setting to disable telemetry in config, ask in chat
 - **23-04-2025 Enhanced edit functionality** - Improved format, added fuzzy search and multi-occurrence replacements, should fail less and use edit block more often
 - **16-04-2025 Better configurations** - Improved settings for allowed paths, commands and shell environments
@@ -333,11 +414,13 @@ The following features are currently being explored:
     <ul style="list-style-type: none; padding: 0;">
       <li>🌟 <a href="https://github.com/sponsors/wonderwhy-er"><strong>GitHub Sponsors</strong></a> - Recurring support</li>
       <li>☕ <a href="https://www.buymeacoffee.com/wonderwhyer"><strong>Buy Me A Coffee</strong></a> - One-time contributions</li>
+      <li>💖 <a href="https://www.patreon.com/c/EduardsRuzga"><strong>Patreon</strong></a> - Become a patron and support us monthly</li>
       <li>⭐ <a href="https://github.com/wonderwhy-er/DesktopCommanderMCP"><strong>Star on GitHub</strong></a> - Help others discover the project</li>
     </ul>
   </div>
 </div>
 
+
 ### Supporters Hall of Fame
 
 Generous supporters are featured here. Thank you for helping make this project possible!

package/dist/config-manager.d.ts

@@ -3,6 +3,8 @@ export interface ServerConfig {
     defaultShell?: string;
     allowedDirectories?: string[];
     telemetryEnabled?: boolean;
+    fileWriteLineLimit?: number;
+    fileReadLineLimit?: number;
     [key: string]: any;
 }
 /**

package/dist/config-manager.js

@@ -101,7 +101,9 @@ class ConfigManager {
             ],
             defaultShell: os.platform() === 'win32' ? 'powershell.exe' : 'bash',
             allowedDirectories: [],
-            telemetryEnabled: true // Default to opt-out approach (telemetry on by default)
+            telemetryEnabled: true, // Default to opt-out approach (telemetry on by default)
+            fileWriteLineLimit: 50, // Default line limit for file write operations (changed from 100)
+            fileReadLineLimit: 1000 // Default line limit for file read operations (changed from character-based)
         };
     }
     /**

package/dist/config.d.ts

@@ -1,4 +1,5 @@
 export declare const USER_HOME: string;
 export declare const CONFIG_FILE: string;
 export declare const TOOL_CALL_FILE: string;
+export declare const TOOL_CALL_FILE_MAX_SIZE: number;
 export declare const DEFAULT_COMMAND_TIMEOUT = 1000;

package/dist/config.js

@@ -6,4 +6,5 @@ const CONFIG_DIR = path.join(USER_HOME, '.claude-server-commander');
 // Paths relative to the config directory
 export const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
 export const TOOL_CALL_FILE = path.join(CONFIG_DIR, 'claude_tool_call.log');
+export const TOOL_CALL_FILE_MAX_SIZE = 1024 * 1024 * 10; // 10 MB
 export const DEFAULT_COMMAND_TIMEOUT = 1000; // milliseconds

package/dist/handlers/filesystem-handlers.js

@@ -1,6 +1,7 @@
 import { readFile, readMultipleFiles, writeFile, createDirectory, listDirectory, moveFile, searchFiles, getFileInfo } from '../tools/filesystem.js';
 import { withTimeout } from '../utils/withTimeout.js';
 import { createErrorResponse } from '../error-handlers.js';
+import { configManager } from '../config-manager.js';
 import { ReadFileArgsSchema, ReadMultipleFilesArgsSchema, WriteFileArgsSchema, CreateDirectoryArgsSchema, ListDirectoryArgsSchema, MoveFileArgsSchema, SearchFilesArgsSchema, GetFileInfoArgsSchema } from '../tools/schemas.js';
 /**
  * Helper function to check if path contains an error
@@ -19,9 +20,22 @@ function getErrorFromPath(path) {
  */
 export async function handleReadFile(args) {
     const HANDLER_TIMEOUT = 60000; // 60 seconds total operation timeout
+    // Add input validation
+    if (args === null || args === undefined) {
+        return createErrorResponse('No arguments provided for read_file command');
+    }
     const readFileOperation = async () => {
         const parsed = ReadFileArgsSchema.parse(args);
-        const fileResult = await readFile(parsed.path, parsed.isUrl);
+        // Get the configuration for file read limits
+        const config = await configManager.getConfig();
+        if (!config) {
+            return createErrorResponse('Configuration not available');
+        }
+        const defaultLimit = config.fileReadLineLimit ?? 1000;
+        // Use the provided limits or defaults
+        const offset = parsed.offset ?? 0;
+        const length = parsed.length ?? defaultLimit;
+        const fileResult = await readFile(parsed.path, parsed.isUrl, offset, length);
         if (fileResult.isImage) {
             // For image files, return as an image content type
             return {
@@ -103,9 +117,29 @@ export async function handleReadMultipleFiles(args) {
 export async function handleWriteFile(args) {
     try {
         const parsed = WriteFileArgsSchema.parse(args);
-        await writeFile(parsed.path, parsed.content);
+        // Get the line limit from configuration
+        const config = await configManager.getConfig();
+        const MAX_LINES = config.fileWriteLineLimit ?? 50; // Default to 50 if not set
+        // Strictly enforce line count limit
+        const lines = parsed.content.split('\n');
+        const lineCount = lines.length;
+        let errorMessage = "";
+        if (lineCount > MAX_LINES) {
+            errorMessage = `File was written with warning: Line count limit exceeded: ${lineCount} lines (maximum: ${MAX_LINES}).
+            
+SOLUTION: Split your content into smaller chunks:
+1. First chunk: write_file(path, firstChunk, {mode: 'rewrite'})
+2. Additional chunks: write_file(path, nextChunk, {mode: 'append'})`;
+        }
+        // Pass the mode parameter to writeFile
+        await writeFile(parsed.path, parsed.content, parsed.mode);
+        // Provide more informative message based on mode
+        const modeMessage = parsed.mode === 'append' ? 'appended to' : 'wrote to';
         return {
-            content: [{ type: "text", text: `Successfully wrote to ${parsed.path}` }],
+            content: [{
+                    type: "text",
+                    text: `Successfully ${modeMessage} ${parsed.path} (${lineCount} lines) ${errorMessage}`
+                }],
         };
     }
     catch (error) {

package/dist/handlers/fuzzy-search-log-handlers.d.ts

@@ -0,0 +1,13 @@
+import { ServerResult } from '../types.js';
+/**
+ * View recent fuzzy search logs
+ */
+export declare function handleViewFuzzySearchLogs(args: unknown): Promise<ServerResult>;
+/**
+ * Analyze fuzzy search logs to identify patterns and issues
+ */
+export declare function handleAnalyzeFuzzySearchLogs(args: unknown): Promise<ServerResult>;
+/**
+ * Clear fuzzy search logs
+ */
+export declare function handleClearFuzzySearchLogs(args: unknown): Promise<ServerResult>;

package/dist/handlers/fuzzy-search-log-handlers.js

@@ -0,0 +1,179 @@
+import { fuzzySearchLogger } from '../utils/fuzzySearchLogger.js';
+import { createErrorResponse } from '../error-handlers.js';
+import { ViewFuzzySearchLogsArgsSchema, AnalyzeFuzzySearchLogsArgsSchema, ClearFuzzySearchLogsArgsSchema } from '../tools/schemas.js';
+/**
+ * View recent fuzzy search logs
+ */
+export async function handleViewFuzzySearchLogs(args) {
+    try {
+        const parsed = ViewFuzzySearchLogsArgsSchema.parse(args);
+        const logs = await fuzzySearchLogger.getRecentLogs(parsed.count);
+        const logPath = await fuzzySearchLogger.getLogPath();
+        if (logs.length === 0) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `No fuzzy search logs found. Log file location: ${logPath}`
+                    }],
+            };
+        }
+        // Parse and format logs for better readability
+        const formattedLogs = logs.map((log, index) => {
+            const parts = log.split('\t');
+            if (parts.length >= 16) {
+                const [timestamp, searchText, foundText, similarity, executionTime, exactMatchCount, expectedReplacements, fuzzyThreshold, belowThreshold, diff, searchLength, foundLength, fileExtension, characterCodes, uniqueCharacterCount, diffLength] = parts;
+                return `
+--- Log Entry ${index + 1} ---
+Timestamp: ${timestamp}
+File Extension: ${fileExtension}
+Search Text: ${searchText.replace(/\\n/g, '\n').replace(/\\t/g, '\t')}
+Found Text: ${foundText.replace(/\\n/g, '\n').replace(/\\t/g, '\t')}
+Similarity: ${(parseFloat(similarity) * 100).toFixed(2)}%
+Execution Time: ${parseFloat(executionTime).toFixed(2)}ms
+Exact Match Count: ${exactMatchCount}
+Expected Replacements: ${expectedReplacements}
+Below Threshold: ${belowThreshold}
+Diff: ${diff.replace(/\\n/g, '\n').replace(/\\t/g, '\t')}
+Search Length: ${searchLength}
+Found Length: ${foundLength}
+Character Codes: ${characterCodes}
+Unique Characters: ${uniqueCharacterCount}
+Diff Length: ${diffLength}
+`;
+            }
+            return `Malformed log entry: ${log}`;
+        }).join('\n');
+        return {
+            content: [{
+                    type: "text",
+                    text: `Recent Fuzzy Search Logs (${logs.length} entries):\n\n${formattedLogs}\n\nLog file location: ${logPath}`
+                }],
+        };
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to view fuzzy search logs: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Analyze fuzzy search logs to identify patterns and issues
+ */
+export async function handleAnalyzeFuzzySearchLogs(args) {
+    try {
+        const parsed = AnalyzeFuzzySearchLogsArgsSchema.parse(args);
+        const logs = await fuzzySearchLogger.getRecentLogs(100); // Analyze more logs
+        const logPath = await fuzzySearchLogger.getLogPath();
+        if (logs.length === 0) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `No fuzzy search logs found. Log file location: ${logPath}`
+                    }],
+            };
+        }
+        // Parse logs and gather statistics
+        let totalEntries = 0;
+        let exactMatches = 0;
+        let fuzzyMatches = 0;
+        let failures = 0;
+        let belowThresholdCount = 0;
+        const executionTimes = [];
+        const similarities = [];
+        const fileExtensions = new Map();
+        const commonCharacterCodes = new Map();
+        for (const log of logs) {
+            const parts = log.split('\t');
+            if (parts.length >= 16) {
+                totalEntries++;
+                const [timestamp, searchText, foundText, similarity, executionTime, exactMatchCount, expectedReplacements, fuzzyThreshold, belowThreshold, diff, searchLength, foundLength, fileExtension, characterCodes, uniqueCharacterCount, diffLength] = parts;
+                const simValue = parseFloat(similarity);
+                const execTime = parseFloat(executionTime);
+                const exactCount = parseInt(exactMatchCount);
+                const belowThresh = belowThreshold === 'true';
+                if (exactCount > 0) {
+                    exactMatches++;
+                }
+                else if (simValue >= parsed.failureThreshold) {
+                    fuzzyMatches++;
+                }
+                else {
+                    failures++;
+                }
+                if (belowThresh) {
+                    belowThresholdCount++;
+                }
+                executionTimes.push(execTime);
+                similarities.push(simValue);
+                // Track file extensions
+                fileExtensions.set(fileExtension, (fileExtensions.get(fileExtension) || 0) + 1);
+                // Track character codes that appear in diffs
+                if (characterCodes && characterCodes !== '') {
+                    const codes = characterCodes.split(',');
+                    for (const code of codes) {
+                        const key = code.split(':')[0];
+                        commonCharacterCodes.set(key, (commonCharacterCodes.get(key) || 0) + 1);
+                    }
+                }
+            }
+        }
+        // Calculate statistics
+        const avgExecutionTime = executionTimes.reduce((a, b) => a + b, 0) / executionTimes.length;
+        const avgSimilarity = similarities.reduce((a, b) => a + b, 0) / similarities.length;
+        // Sort by frequency
+        const sortedExtensions = Array.from(fileExtensions.entries()).sort((a, b) => b[1] - a[1]);
+        const sortedCharCodes = Array.from(commonCharacterCodes.entries()).sort((a, b) => b[1] - a[1]);
+        const analysis = `
+=== Fuzzy Search Analysis ===
+
+Total Entries: ${totalEntries}
+Exact Matches: ${exactMatches} (${((exactMatches / totalEntries) * 100).toFixed(2)}%)
+Fuzzy Matches: ${fuzzyMatches} (${((fuzzyMatches / totalEntries) * 100).toFixed(2)}%)
+Failures: ${failures} (${((failures / totalEntries) * 100).toFixed(2)}%)
+Below Threshold: ${belowThresholdCount} (${((belowThresholdCount / totalEntries) * 100).toFixed(2)}%)
+
+Performance:
+Average Execution Time: ${avgExecutionTime.toFixed(2)}ms
+Average Similarity: ${(avgSimilarity * 100).toFixed(2)}%
+
+File Extensions (Top 5):
+${sortedExtensions.slice(0, 5).map(([ext, count]) => `${ext || 'none'}: ${count} times`).join('\n')}
+
+Common Character Codes in Diffs (Top 5):
+${sortedCharCodes.slice(0, 5).map(([code, count]) => {
+            const charCode = parseInt(code);
+            const char = String.fromCharCode(charCode);
+            const display = charCode < 32 || charCode > 126 ? `\\x${charCode.toString(16).padStart(2, '0')}` : char;
+            return `${code} [${display}]: ${count} times`;
+        }).join('\n')}
+
+Log file location: ${logPath}
+`;
+        return {
+            content: [{
+                    type: "text",
+                    text: analysis
+                }],
+        };
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to analyze fuzzy search logs: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Clear fuzzy search logs
+ */
+export async function handleClearFuzzySearchLogs(args) {
+    try {
+        ClearFuzzySearchLogsArgsSchema.parse(args);
+        await fuzzySearchLogger.clearLog();
+        const logPath = await fuzzySearchLogger.getLogPath();
+        return {
+            content: [{
+                    type: "text",
+                    text: `Fuzzy search logs cleared. Log file location: ${logPath}`
+                }],
+        };
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to clear fuzzy search logs: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/dist/server.js

@@ -3,8 +3,10 @@ import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSche
 import { zodToJsonSchema } from "zod-to-json-schema";
 // Shared constants for tool descriptions
 const PATH_GUIDANCE = `IMPORTANT: Always use absolute paths (starting with '/' or drive letter like 'C:\\') for reliability. Relative paths may fail as they depend on the current working directory. Tilde paths (~/...) might not work in all contexts. Unless the user explicitly asks for relative paths, use absolute paths.`;
+const CMD_PREFIX_DESCRIPTION = `This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.`;
 import { ExecuteCommandArgsSchema, ReadOutputArgsSchema, ForceTerminateArgsSchema, ListSessionsArgsSchema, KillProcessArgsSchema, ReadFileArgsSchema, ReadMultipleFilesArgsSchema, WriteFileArgsSchema, CreateDirectoryArgsSchema, ListDirectoryArgsSchema, MoveFileArgsSchema, SearchFilesArgsSchema, GetFileInfoArgsSchema, SearchCodeArgsSchema, GetConfigArgsSchema, SetConfigValueArgsSchema, ListProcessesArgsSchema, EditBlockArgsSchema, } from './tools/schemas.js';
 import { getConfig, setConfigValue } from './tools/config.js';
+import { trackToolCall } from './utils/trackTools.js';
 import { VERSION } from './version.js';
 import { capture } from "./utils/capture.js";
 console.error("Loading server.ts");
@@ -41,45 +43,58 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                 // Configuration tools
                 {
                     name: "get_config",
-                    description: "Get the complete server configuration as JSON. Config includes fields for: blockedCommands (array of blocked shell commands), defaultShell (shell to use for commands), allowedDirectories (paths the server can access).",
+                    description: `Get the complete server configuration as JSON. Config includes fields for: blockedCommands (array of blocked shell commands), defaultShell (shell to use for commands), allowedDirectories (paths the server can access), fileReadLineLimit (max lines for read_file, default 1000), fileWriteLineLimit (max lines per write_file call, default 50), telemetryEnabled (boolean for telemetry opt-in/out). ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(GetConfigArgsSchema),
                 },
                 {
                     name: "set_config_value",
-                    description: "Set a specific configuration value by key. WARNING: Should be used in a separate chat from file operations and command execution to prevent security issues. Config keys include: blockedCommands (array), defaultShell (string), allowedDirectories (array of paths). IMPORTANT: Setting allowedDirectories to an empty array ([]) allows full access to the entire file system, regardless of the operating system.",
+                    description: `Set a specific configuration value by key. WARNING: Should be used in a separate chat from file operations and command execution to prevent security issues. Config keys include: blockedCommands (array), defaultShell (string), allowedDirectories (array of paths), fileReadLineLimit (number, max lines for read_file), fileWriteLineLimit (number, max lines per write_file call), telemetryEnabled (boolean). IMPORTANT: Setting allowedDirectories to an empty array ([]) allows full access to the entire file system, regardless of the operating system. ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(SetConfigValueArgsSchema),
                 },
                 // Filesystem tools
                 {
                     name: "read_file",
-                    description: `Read the complete contents of a file from the file system or a URL. Prefer this over 'execute_command' with cat/type for viewing files. When reading from the file system, only works within allowed directories. Can fetch content from URLs when isUrl parameter is set to true. Handles text files normally and image files are returned as viewable images. Recognized image types: PNG, JPEG, GIF, WebP. ${PATH_GUIDANCE}`,
+                    description: `Read the contents of a file from the file system or a URL with optional offset and length parameters. Prefer this over 'execute_command' with cat/type for viewing files. Supports partial file reading with 'offset' (start line, default: 0) and 'length' (max lines to read, default: configurable via 'fileReadLineLimit' setting, initially 1000). When reading from the file system, only works within allowed directories. Can fetch content from URLs when isUrl parameter is set to true (URLs are always read in full regardless of offset/length). Handles text files normally and image files are returned as viewable images. Recognized image types: PNG, JPEG, GIF, WebP. ${PATH_GUIDANCE} ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(ReadFileArgsSchema),
                 },
                 {
                     name: "read_multiple_files",
-                    description: `Read the contents of multiple files simultaneously. Each file's content is returned with its path as a reference. Handles text files normally and renders images as viewable content. Recognized image types: PNG, JPEG, GIF, WebP. Failed reads for individual files won't stop the entire operation. Only works within allowed directories. ${PATH_GUIDANCE}`,
+                    description: `Read the contents of multiple files simultaneously. Each file's content is returned with its path as a reference. Handles text files normally and renders images as viewable content. Recognized image types: PNG, JPEG, GIF, WebP. Failed reads for individual files won't stop the entire operation. Only works within allowed directories. ${PATH_GUIDANCE} ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(ReadMultipleFilesArgsSchema),
                 },
                 {
                     name: "write_file",
-                    description: `Completely replace file contents. Best for large changes (>20% of file) or when edit_block fails. Use with caution as it will overwrite existing files. Only works within allowed directories. ${PATH_GUIDANCE}`,
+                    description: `Write or append to file contents with a configurable line limit per call (default: 50 lines). THIS IS A STRICT REQUIREMENT. ANY file with more than the configured limit MUST BE written in chunks or IT WILL FAIL.
+
+                        NEVER attempt to write more than the configured line limit at once.
+
+                        REQUIRED PROCESS FOR LARGE FILES:
+                        1. FIRST → write_file(filePath, firstChunk, {mode: 'rewrite'})
+                        2. THEN → write_file(filePath, secondChunk, {mode: 'append'})
+                        3. THEN → write_file(filePath, thirdChunk, {mode: 'append'})
+                        ... and so on for each chunk
+                        
+                        If asked to continue writing do not restart from beginning, read end of file to see where you stopped and continue from there
+
+                        Files over the line limit (configurable via 'fileWriteLineLimit' setting) WILL BE REJECTED if not broken into chunks as described above.
+                        Only works within allowed directories. ${PATH_GUIDANCE} ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(WriteFileArgsSchema),
                 },
                 {
                     name: "create_directory",
-                    description: `Create a new directory or ensure a directory exists. Can create multiple nested directories in one operation. Only works within allowed directories. ${PATH_GUIDANCE}`,
+                    description: `Create a new directory or ensure a directory exists. Can create multiple nested directories in one operation. Only works within allowed directories. ${PATH_GUIDANCE} ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(CreateDirectoryArgsSchema),
                 },
                 {
                     name: "list_directory",
-                    description: `Get a detailed listing of all files and directories in a specified path. Use this instead of 'execute_command' with ls/dir commands. Results distinguish between files and directories with [FILE] and [DIR] prefixes. Only works within allowed directories. ${PATH_GUIDANCE}`,
+                    description: `Get a detailed listing of all files and directories in a specified path. Use this instead of 'execute_command' with ls/dir commands. Results distinguish between files and directories with [FILE] and [DIR] prefixes. Only works within allowed directories. ${PATH_GUIDANCE} ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(ListDirectoryArgsSchema),
                 },
                 {
                     name: "move_file",
                     description: `Move or rename files and directories. 
                         Can move files between directories and rename them in a single operation. 
-                        Both source and destination must be within allowed directories. ${PATH_GUIDANCE}`,
+                        Both source and destination must be within allowed directories. ${PATH_GUIDANCE} ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(MoveFileArgsSchema),
                 },
                 {
@@ -88,7 +103,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         Use this instead of 'execute_command' with find/dir/ls for locating files.
                         Searches through all subdirectories from the starting path. 
                         Has a default timeout of 30 seconds which can be customized using the timeoutMs parameter. 
-                        Only searches within allowed directories. ${PATH_GUIDANCE}`,
+                        Only searches within allowed directories. ${PATH_GUIDANCE} ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(SearchFilesArgsSchema),
                 },
                 {
@@ -99,14 +114,14 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         Supports regular expressions, file pattern filtering, and context lines. 
                         Has a default timeout of 30 seconds which can be customized. 
                         Only searches within allowed directories. 
-                        ${PATH_GUIDANCE}`,
+                        ${PATH_GUIDANCE} ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(SearchCodeArgsSchema),
                 },
                 {
                     name: "get_file_info",
                     description: `Retrieve detailed metadata about a file or directory including size, creation time, last modified time, 
                         permissions, and type. 
-                        Only works within allowed directories. ${PATH_GUIDANCE}`,
+                        Only works within allowed directories. ${PATH_GUIDANCE} ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(GetFileInfoArgsSchema),
                 },
                 // Note: list_allowed_directories removed - use get_config to check allowedDirectories
@@ -121,8 +136,9 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         To replace multiple occurrences, provide the expected_replacements parameter with the exact number of matches expected. 
                         UNIQUENESS REQUIREMENT: When expected_replacements=1 (default), include the minimal amount of context necessary (typically 1-3 lines) before and after the change point, with exact whitespace and indentation. 
                         When editing multiple sections, make separate edit_block calls for each distinct change rather than one large replacement. 
-                        When a close but non-exact match is found, a character-level diff is shown in the format: common_prefix{-removed-}{+added+}common_suffix to help you identify what's different. 
-                        ${PATH_GUIDANCE}`,
+                        When a close but non-exact match is found, a character-level diff is shown in the format: common_prefix{-removed-}{+added+}common_suffix to help you identify what's different.
+                        Similar to write_file, there is a configurable line limit (fileWriteLineLimit) that warns if the edited file exceeds this limit. If this happens, consider breaking your edits into smaller, more focused changes.
+                        ${PATH_GUIDANCE} ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(EditBlockArgsSchema),
                 },
                 // Terminal tools
@@ -131,32 +147,32 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     description: `Execute a terminal command with timeout. 
                         Command will continue running in background if it doesn't complete within timeout. 
                         NOTE: For file operations, prefer specialized tools like read_file, search_code, list_directory instead of cat, grep, or ls commands.
-                        ${PATH_GUIDANCE}`,
+                        ${PATH_GUIDANCE} ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(ExecuteCommandArgsSchema),
                 },
                 {
                     name: "read_output",
-                    description: "Read new output from a running terminal session.",
+                    description: `Read new output from a running terminal session. ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(ReadOutputArgsSchema),
                 },
                 {
                     name: "force_terminate",
-                    description: "Force terminate a running terminal session.",
+                    description: `Force terminate a running terminal session. ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(ForceTerminateArgsSchema),
                 },
                 {
                     name: "list_sessions",
-                    description: "List all active terminal sessions.",
+                    description: `List all active terminal sessions. ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(ListSessionsArgsSchema),
                 },
                 {
                     name: "list_processes",
-                    description: "List all running processes. Returns process information including PID, command name, CPU usage, and memory usage.",
+                    description: `List all running processes. Returns process information including PID, command name, CPU usage, and memory usage. ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(ListProcessesArgsSchema),
                 },
                 {
                     name: "kill_process",
-                    description: "Terminate a running process by PID. Use with caution as this will forcefully terminate the specified process.",
+                    description: `Terminate a running process by PID. Use with caution as this will forcefully terminate the specified process. ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(KillProcessArgsSchema),
                 },
             ],
@@ -174,6 +190,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         capture('server_call_tool', {
             name
         });
+        // Track tool call
+        trackToolCall(name, args);
         // Using a more structured approach with dedicated handlers
         switch (name) {
             // Config tools

package/dist/setup-claude-server.js

@@ -385,26 +385,6 @@ function updateSetupStep(index, status, error = null) {
     }
 }
 
-try {
-    // Only dependency is node-machine-id
-    const machineIdInitStep = addSetupStep('initialize_machine_id');
-    try {
-        const machineIdModule = await import('node-machine-id');
-        // Get a unique user ID
-        uniqueUserId = machineIdModule.machineIdSync();
-        updateSetupStep(machineIdInitStep, 'completed');
-    } catch (error) {
-        // Fall back to a semi-unique identifier if machine-id is not available
-        uniqueUserId = `${platform()}-${process.env.USER || process.env.USERNAME || 'unknown'}-${Date.now()}`;
-        updateSetupStep(machineIdInitStep, 'fallback', error);
-    }
-} catch (error) {
-    addSetupStep('initialize_machine_id', 'failed', error);
-}
-
-
-
-
 async function execAsync(command) {
     const execStep = addSetupStep(`exec_${command.substring(0, 20)}...`);
     return new Promise((resolve, reject) => {

package/dist/tools/edit.js

@@ -4,6 +4,8 @@ import { capture } from '../utils/capture.js';
 import { EditBlockArgsSchema } from "./schemas.js";
 import path from 'path';
 import { detectLineEnding, normalizeLineEndings } from '../utils/lineEndingHandler.js';
+import { configManager } from '../config-manager.js';
+import { fuzzySearchLogger } from '../utils/fuzzySearchLogger.js';
 /**
  * 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)
@@ -76,11 +78,14 @@ export async function performSearchReplace(filePath, block, expectedReplacements
     // 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);
+    const { content } = await readFile(filePath, false, 0, Number.MAX_SAFE_INTEGER);
     // Make sure content is a string
     if (typeof content !== 'string') {
         throw new Error('Wrong content for file ' + filePath);
     }
+    // Get the line limit from configuration
+    const config = await configManager.getConfig();
+    const MAX_LINES = config.fileWriteLineLimit ?? 50; // Default to 50 if not set
     // Detect file's line ending style
     const fileLineEnding = detectLineEnding(content);
     // Normalize search string to match file's line endings
@@ -109,11 +114,22 @@ export async function performSearchReplace(filePath, block, expectedReplacements
             // Replace all occurrences using split and join for multiple replacements
             newContent = newContent.split(normalizedSearch).join(normalizeLineEndings(block.replace, fileLineEnding));
         }
+        // Check if search or replace text has too many lines
+        const searchLines = block.search.split('\n').length;
+        const replaceLines = block.replace.split('\n').length;
+        const maxLines = Math.max(searchLines, replaceLines);
+        let warningMessage = "";
+        if (maxLines > MAX_LINES) {
+            const problemText = searchLines > replaceLines ? 'search text' : 'replacement text';
+            warningMessage = `\n\nWARNING: The ${problemText} has ${maxLines} lines (maximum: ${MAX_LINES}).
+            
+RECOMMENDATION: For large search/replace operations, consider breaking them into smaller chunks with fewer lines.`;
+        }
         await writeFile(filePath, newContent);
         return {
             content: [{
                     type: "text",
-                    text: `Successfully applied ${expectedReplacements} edit${expectedReplacements > 1 ? 's' : ''} to ${filePath}`
+                    text: `Successfully applied ${expectedReplacements} edit${expectedReplacements > 1 ? 's' : ''} to ${filePath}${warningMessage}`
                 }],
         };
     }
@@ -142,6 +158,27 @@ export async function performSearchReplace(filePath, block, expectedReplacements
         const diff = highlightDifferences(block.search, fuzzyResult.value);
         // Count character codes in diff
         const characterCodeData = getCharacterCodeData(block.search, fuzzyResult.value);
+        // Create comprehensive log entry
+        const logEntry = {
+            timestamp: new Date(),
+            searchText: block.search,
+            foundText: fuzzyResult.value,
+            similarity: similarity,
+            executionTime: executionTime,
+            exactMatchCount: count,
+            expectedReplacements: expectedReplacements,
+            fuzzyThreshold: FUZZY_THRESHOLD,
+            belowThreshold: similarity < FUZZY_THRESHOLD,
+            diff: diff,
+            searchLength: block.search.length,
+            foundLength: fuzzyResult.value.length,
+            fileExtension: fileExtension,
+            characterCodes: characterCodeData.report,
+            uniqueCharacterCount: characterCodeData.uniqueCount,
+            diffLength: characterCodeData.diffLength
+        };
+        // Log to file
+        await fuzzySearchLogger.log(logEntry);
         // Combine all fuzzy search data for single capture
         const fuzzySearchData = {
             similarity: similarity,
@@ -165,8 +202,10 @@ export async function performSearchReplace(filePath, block, expectedReplacements
                         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.`
-                    }],
+                            `To replace this text, use the exact text found in the file.\n\n` +
+                            `Log entry saved for analysis. Use the following command to check the log:\n` +
+                            `Check log: ${await fuzzySearchLogger.getLogPath()}`
+                    }], // TODO
             };
         }
         else {
@@ -181,7 +220,9 @@ export async function performSearchReplace(filePath, block, expectedReplacements
                         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)`
+                            `(Fuzzy search completed in ${executionTime.toFixed(2)}ms)\n\n` +
+                            `Log entry saved for analysis. Use the following command to check the log:\n` +
+                            `Check log: ${await fuzzySearchLogger.getLogPath()}`
                     }],
             };
         }

package/dist/tools/filesystem.d.ts

@@ -22,19 +22,21 @@ export declare function readFileFromUrl(url: string): Promise<FileResult>;
 /**
  * Read file content from the local filesystem
  * @param filePath Path to the file
- * @param returnMetadata Whether to return metadata with the content
+ * @param offset Starting line number to read from (default: 0)
+ * @param length Maximum number of lines to read (default: from config or 1000)
  * @returns File content or file result with metadata
  */
-export declare function readFileFromDisk(filePath: string): Promise<FileResult>;
+export declare function readFileFromDisk(filePath: string, offset?: number, length?: number): Promise<FileResult>;
 /**
  * Read a file from either the local filesystem or a URL
  * @param filePath Path to the file or URL
- * @param returnMetadata Whether to return metadata with the content
  * @param isUrl Whether the path is a URL
+ * @param offset Starting line number to read from (default: 0)
+ * @param length Maximum number of lines to read (default: from config or 1000)
  * @returns File content or file result with metadata
  */
-export declare function readFile(filePath: string, isUrl?: boolean): Promise<FileResult>;
-export declare function writeFile(filePath: string, content: string): Promise<void>;
+export declare function readFile(filePath: string, isUrl?: boolean, offset?: number, length?: number): Promise<FileResult>;
+export declare function writeFile(filePath: string, content: string, mode?: 'rewrite' | 'append'): Promise<void>;
 export interface MultiFileResult {
     path: string;
     content?: string;

package/dist/tools/filesystem.js

@@ -208,38 +208,41 @@ export async function readFileFromUrl(url) {
 /**
  * Read file content from the local filesystem
  * @param filePath Path to the file
- * @param returnMetadata Whether to return metadata with the content
+ * @param offset Starting line number to read from (default: 0)
+ * @param length Maximum number of lines to read (default: from config or 1000)
  * @returns File content or file result with metadata
  */
-export async function readFileFromDisk(filePath) {
+export async function readFileFromDisk(filePath, offset = 0, length) {
+    // Add validation for required parameters
+    if (!filePath || typeof filePath !== 'string') {
+        throw new Error('Invalid file path provided');
+    }
     // Import the MIME type utilities
     const { getMimeType, isImageFile } = await import('./mime-types.js');
+    // Get default length from config if not provided
+    if (length === undefined) {
+        const config = await configManager.getConfig();
+        length = config.fileReadLineLimit ?? 1000; // Default to 1000 lines if not set
+    }
     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 });
+        capture('server_read_file', {
+            fileExtension: fileExtension,
+            offset: offset,
+            length: length,
+            fileSize: stats.size
+        });
     }
     catch (error) {
         console.error('error catch ' + 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);
     }
     // Detect the MIME type based on file extension
     const mimeType = getMimeType(validPath);
@@ -249,15 +252,30 @@ export async function readFileFromDisk(filePath) {
     const readOperation = async () => {
         if (isImage) {
             // For image files, read as Buffer and convert to base64
+            // Images are always read in full, ignoring offset and length
             const buffer = await fs.readFile(validPath);
             const content = buffer.toString('base64');
             return { content, mimeType, isImage };
         }
         else {
-            // For all other files, try to read as UTF-8 text
+            // For all other files, try to read as UTF-8 text with line-based offset and length
             try {
+                // Read the entire file first
                 const buffer = await fs.readFile(validPath);
-                const content = buffer.toString('utf-8');
+                const fullContent = buffer.toString('utf-8');
+                // Split into lines for line-based access
+                const lines = fullContent.split('\n');
+                const totalLines = lines.length;
+                // Apply line-based offset and length
+                const startLine = Math.min(offset, totalLines);
+                const endLine = Math.min(startLine + length, totalLines);
+                const selectedLines = lines.slice(startLine, endLine);
+                const truncatedContent = selectedLines.join('\n');
+                // Add an informational message if truncated
+                let content = truncatedContent;
+                if (offset > 0 || endLine < totalLines) {
+                    content = `[Reading ${endLine - startLine} lines from line ${offset} of ${totalLines} total lines]\n\n${truncatedContent}`;
+                }
                 return { content, mimeType, isImage };
             }
             catch (error) {
@@ -279,22 +297,32 @@ export async function readFileFromDisk(filePath) {
 /**
  * Read a file from either the local filesystem or a URL
  * @param filePath Path to the file or URL
- * @param returnMetadata Whether to return metadata with the content
  * @param isUrl Whether the path is a URL
+ * @param offset Starting line number to read from (default: 0)
+ * @param length Maximum number of lines to read (default: from config or 1000)
  * @returns File content or file result with metadata
  */
-export async function readFile(filePath, isUrl) {
+export async function readFile(filePath, isUrl, offset, length) {
     return isUrl
         ? readFileFromUrl(filePath)
-        : readFileFromDisk(filePath);
+        : readFileFromDisk(filePath, offset, length);
 }
-export async function writeFile(filePath, content) {
+export async function writeFile(filePath, content, mode = 'rewrite') {
     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);
+    // Capture file extension and operation details in telemetry without capturing the file path
+    capture('server_write_file', {
+        fileExtension: fileExtension,
+        mode: mode,
+    });
+    // Use different fs methods based on mode
+    if (mode === 'append') {
+        await fs.appendFile(validPath, content);
+    }
+    else {
+        await fs.writeFile(validPath, content);
+    }
 }
 export async function readMultipleFiles(paths) {
     return Promise.all(paths.map(async (filePath) => {

package/dist/tools/schemas.d.ts

@@ -49,12 +49,18 @@ export declare const KillProcessArgsSchema: z.ZodObject<{
 export declare const ReadFileArgsSchema: z.ZodObject<{
     path: z.ZodString;
     isUrl: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    offset: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    length: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
 }, "strip", z.ZodTypeAny, {
     path: string;
+    length: number;
     isUrl: boolean;
+    offset: number;
 }, {
     path: string;
+    length?: number | undefined;
     isUrl?: boolean | undefined;
+    offset?: number | undefined;
 }>;
 export declare const ReadMultipleFilesArgsSchema: z.ZodObject<{
     paths: z.ZodArray<z.ZodString, "many">;
@@ -66,12 +72,15 @@ export declare const ReadMultipleFilesArgsSchema: z.ZodObject<{
 export declare const WriteFileArgsSchema: z.ZodObject<{
     path: z.ZodString;
     content: z.ZodString;
+    mode: z.ZodDefault<z.ZodEnum<["rewrite", "append"]>>;
 }, "strip", z.ZodTypeAny, {
     path: string;
     content: string;
+    mode: "rewrite" | "append";
 }, {
     path: string;
     content: string;
+    mode?: "rewrite" | "append" | undefined;
 }>;
 export declare const CreateDirectoryArgsSchema: z.ZodObject<{
     path: z.ZodString;

package/dist/tools/schemas.js

@@ -28,6 +28,8 @@ export const KillProcessArgsSchema = z.object({
 export const ReadFileArgsSchema = z.object({
     path: z.string(),
     isUrl: z.boolean().optional().default(false),
+    offset: z.number().optional().default(0),
+    length: z.number().optional().default(1000),
 });
 export const ReadMultipleFilesArgsSchema = z.object({
     paths: z.array(z.string()),
@@ -35,6 +37,7 @@ export const ReadMultipleFilesArgsSchema = z.object({
 export const WriteFileArgsSchema = z.object({
     path: z.string(),
     content: z.string(),
+    mode: z.enum(['rewrite', 'append']).default('rewrite'),
 });
 export const CreateDirectoryArgsSchema = z.object({
     path: z.string(),

package/dist/utils/fuzzySearchLogger.d.ts

@@ -0,0 +1,30 @@
+export interface FuzzySearchLogEntry {
+    timestamp: Date;
+    searchText: string;
+    foundText: string;
+    similarity: number;
+    executionTime: number;
+    exactMatchCount: number;
+    expectedReplacements: number;
+    fuzzyThreshold: number;
+    belowThreshold: boolean;
+    diff: string;
+    searchLength: number;
+    foundLength: number;
+    fileExtension: string;
+    characterCodes: string;
+    uniqueCharacterCount: number;
+    diffLength: number;
+}
+declare class FuzzySearchLogger {
+    private logPath;
+    private initialized;
+    constructor();
+    private ensureLogFile;
+    log(entry: FuzzySearchLogEntry): Promise<void>;
+    getLogPath(): Promise<string>;
+    getRecentLogs(count?: number): Promise<string[]>;
+    clearLog(): Promise<void>;
+}
+export declare const fuzzySearchLogger: FuzzySearchLogger;
+export {};

package/dist/utils/fuzzySearchLogger.js

@@ -0,0 +1,126 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+class FuzzySearchLogger {
+    constructor() {
+        this.initialized = false;
+        // Create log file in a dedicated directory
+        const logDir = path.join(os.homedir(), '.claude-server-commander-logs');
+        this.logPath = path.join(logDir, 'fuzzy-search.log');
+    }
+    async ensureLogFile() {
+        if (this.initialized)
+            return;
+        try {
+            // Create log directory if it doesn't exist
+            const logDir = path.dirname(this.logPath);
+            await fs.mkdir(logDir, { recursive: true });
+            // Check if log file exists, create with headers if not
+            try {
+                await fs.access(this.logPath);
+            }
+            catch {
+                // File doesn't exist, create with headers
+                const headers = [
+                    'timestamp',
+                    'searchText',
+                    'foundText',
+                    'similarity',
+                    'executionTime',
+                    'exactMatchCount',
+                    'expectedReplacements',
+                    'fuzzyThreshold',
+                    'belowThreshold',
+                    'diff',
+                    'searchLength',
+                    'foundLength',
+                    'fileExtension',
+                    'characterCodes',
+                    'uniqueCharacterCount',
+                    'diffLength'
+                ].join('\t');
+                await fs.writeFile(this.logPath, headers + '\n');
+            }
+            this.initialized = true;
+        }
+        catch (error) {
+            console.error('Failed to initialize fuzzy search log file:', error);
+            throw error;
+        }
+    }
+    async log(entry) {
+        try {
+            await this.ensureLogFile();
+            // Convert entry to tab-separated string
+            const logLine = [
+                entry.timestamp.toISOString(),
+                entry.searchText.replace(/\n/g, '\\n').replace(/\t/g, '\\t'),
+                entry.foundText.replace(/\n/g, '\\n').replace(/\t/g, '\\t'),
+                entry.similarity.toString(),
+                entry.executionTime.toString(),
+                entry.exactMatchCount.toString(),
+                entry.expectedReplacements.toString(),
+                entry.fuzzyThreshold.toString(),
+                entry.belowThreshold.toString(),
+                entry.diff.replace(/\n/g, '\\n').replace(/\t/g, '\\t'),
+                entry.searchLength.toString(),
+                entry.foundLength.toString(),
+                entry.fileExtension,
+                entry.characterCodes,
+                entry.uniqueCharacterCount.toString(),
+                entry.diffLength.toString()
+            ].join('\t');
+            await fs.appendFile(this.logPath, logLine + '\n');
+        }
+        catch (error) {
+            console.error('Failed to write to fuzzy search log:', error);
+        }
+    }
+    async getLogPath() {
+        await this.ensureLogFile();
+        return this.logPath;
+    }
+    async getRecentLogs(count = 10) {
+        try {
+            await this.ensureLogFile();
+            const content = await fs.readFile(this.logPath, 'utf-8');
+            const lines = content.split('\n').filter(line => line.trim());
+            // Return last N lines (excluding header)
+            return lines.slice(-count - 1, -1);
+        }
+        catch (error) {
+            console.error('Failed to read fuzzy search logs:', error);
+            return [];
+        }
+    }
+    async clearLog() {
+        try {
+            // Recreate with just headers
+            const headers = [
+                'timestamp',
+                'searchText',
+                'foundText',
+                'similarity',
+                'executionTime',
+                'exactMatchCount',
+                'expectedReplacements',
+                'fuzzyThreshold',
+                'belowThreshold',
+                'diff',
+                'searchLength',
+                'foundLength',
+                'fileExtension',
+                'characterCodes',
+                'uniqueCharacterCount',
+                'diffLength'
+            ].join('\t');
+            await fs.writeFile(this.logPath, headers + '\n');
+            console.log('Fuzzy search log cleared');
+        }
+        catch (error) {
+            console.error('Failed to clear fuzzy search log:', error);
+        }
+    }
+}
+// Singleton instance
+export const fuzzySearchLogger = new FuzzySearchLogger();

package/dist/utils/trackTools.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Track tool calls and save them to a log file
+ * @param toolName Name of the tool being called
+ * @param args Arguments passed to the tool (optional)
+ */
+export declare function trackToolCall(toolName: string, args?: unknown): Promise<void>;

package/dist/utils/trackTools.js

@@ -0,0 +1,54 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { TOOL_CALL_FILE, TOOL_CALL_FILE_MAX_SIZE } from '../config.js';
+// Ensure the directory for the log file exists
+const logDir = path.dirname(TOOL_CALL_FILE);
+await fs.promises.mkdir(logDir, { recursive: true });
+/**
+ * Track tool calls and save them to a log file
+ * @param toolName Name of the tool being called
+ * @param args Arguments passed to the tool (optional)
+ */
+export async function trackToolCall(toolName, args) {
+    try {
+        // Get current timestamp
+        const timestamp = new Date().toISOString();
+        // Format the log entry
+        const logEntry = `${timestamp} | ${toolName.padEnd(20, ' ')}${args ? `\t| Arguments: ${JSON.stringify(args)}` : ''}\n`;
+        // Check if file exists and get its size
+        let fileSize = 0;
+        try {
+            const stats = await fs.promises.stat(TOOL_CALL_FILE);
+            fileSize = stats.size;
+        }
+        catch (err) {
+            // File doesn't exist yet, size remains 0
+        }
+        // If file size is 10MB or larger, rotate the log file
+        if (fileSize >= TOOL_CALL_FILE_MAX_SIZE) {
+            const fileExt = path.extname(TOOL_CALL_FILE);
+            const fileBase = path.basename(TOOL_CALL_FILE, fileExt);
+            const dirName = path.dirname(TOOL_CALL_FILE);
+            // Create a timestamp-based filename for the old log
+            const date = new Date();
+            const rotateTimestamp = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}_${String(date.getHours()).padStart(2, '0')}-${String(date.getMinutes()).padStart(2, '0')}-${String(date.getSeconds()).padStart(2, '0')}`;
+            const newFileName = path.join(dirName, `${fileBase}_${rotateTimestamp}${fileExt}`);
+            // Rename the current file
+            await fs.promises.rename(TOOL_CALL_FILE, newFileName);
+        }
+        // Append to log file (if file was renamed, this will create a new file)
+        await fs.promises.appendFile(TOOL_CALL_FILE, logEntry, 'utf8');
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const { capture } = await import('./capture.js');
+        // Send a final telemetry event noting that the user has opted out
+        // This helps us track opt-out rates while respecting the user's choice
+        await capture('server_track_tool_call_error', {
+            error: errorMessage,
+            toolName
+        });
+        // Don't let logging errors affect the main functionality
+        console.error(`Error logging tool call: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.1.39";
+export declare const VERSION = "0.2.0";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.1.39';
+export const VERSION = '0.2.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wonderwhy-er/desktop-commander",
-  "version": "0.1.39",
+  "version": "0.2.0",
   "description": "MCP server for terminal operations and file editing",
   "license": "MIT",
   "author": "Eduards Ruzga",
@@ -34,7 +34,11 @@
     "test": "node test/run-all-tests.js",
     "link:local": "npm run build && npm link",
     "unlink:local": "npm unlink",
-    "inspector": "npx @modelcontextprotocol/inspector dist/index.js"
+    "inspector": "npx @modelcontextprotocol/inspector dist/index.js",
+    "logs:view": "npm run build && node scripts/view-fuzzy-logs.js",
+    "logs:analyze": "npm run build && node scripts/analyze-fuzzy-logs.js",
+    "logs:clear": "npm run build && node scripts/clear-fuzzy-logs.js",
+    "logs:export": "npm run build && node scripts/export-fuzzy-logs.js"
   },
   "publishConfig": {
     "access": "public"
@@ -69,6 +73,7 @@
   },
   "devDependencies": {
     "@types/node": "^20.17.24",
+    "commander": "^13.1.0",
     "nexe": "^5.0.0-beta.4",
     "nodemon": "^3.0.2",
     "shx": "^0.3.4",