@wonderwhy-er/desktop-commander 0.2.2 → 0.2.3

package/README.md

@@ -52,6 +52,7 @@ Execute long-running terminal commands on your computer and manage processes thr
   - Move files/directories
   - Search files
   - Get file metadata
+  - **Negative offset file reading**: Read from end of files using negative offset values (like Unix tail)
 - Code editing capabilities:
   - Surgical text replacements for small changes
   - Full file rewrites for major changes
@@ -187,7 +188,7 @@ The server provides a comprehensive set of tools organized into several categori
 | | `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 with line-based pagination (supports offset and length parameters) |
+| **Filesystem** | `read_file` | Read contents from local filesystem or URLs with line-based pagination (supports positive/negative offset and length parameters) |
 | | `read_multiple_files` | Read multiple files simultaneously |
 | | `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 |

package/dist/handlers/filesystem-handlers.js

@@ -125,11 +125,9 @@ export async function handleWriteFile(args) {
         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}).
+            errorMessage = `✅ File written successfully! (${lineCount} 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'})`;
+💡 Performance tip: For optimal speed, consider chunking files into ≤30 line pieces in future operations.`;
         }
         // Pass the mode parameter to writeFile
         await writeFile(parsed.path, parsed.content, parsed.mode);

package/dist/server.js

@@ -8,7 +8,7 @@ import { ExecuteCommandArgsSchema, ReadOutputArgsSchema, ForceTerminateArgsSchem
 import { getConfig, setConfigValue } from './tools/config.js';
 import { trackToolCall } from './utils/trackTools.js';
 import { VERSION } from './version.js';
-import { capture } from "./utils/capture.js";
+import { capture, capture_call_tool } from "./utils/capture.js";
 console.error("Loading server.ts");
 export const server = new Server({
     name: "desktop-commander",
@@ -87,7 +87,22 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         
                         Supports partial file reading with:
                         - 'offset' (start line, default: 0)
+                          * Positive: Start from line N (0-based indexing)
+                          * Negative: Read last N lines from end (tail behavior)
                         - 'length' (max lines to read, default: configurable via 'fileReadLineLimit' setting, initially 1000)
+                          * Used with positive offsets for range reading
+                          * Ignored when offset is negative (reads all requested tail lines)
+                        
+                        Examples:
+                        - offset: 0, length: 10     → First 10 lines
+                        - offset: 100, length: 5    → Lines 100-104
+                        - offset: -20               → Last 20 lines  
+                        - offset: -5, length: 10    → Last 5 lines (length ignored)
+                        
+                        Performance optimizations:
+                        - Large files with negative offsets use reverse reading for efficiency
+                        - Large files with deep positive offsets use byte estimation
+                        - Small files use fast readline streaming
                         
                         When reading from the file system, only works within allowed directories.
                         Can fetch content from URLs when isUrl parameter is set to true
@@ -119,30 +134,30 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                 {
                     name: "write_file",
                     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.
+                        Write or append to file contents. 
+
+                        🎯 CHUNKING IS STANDARD PRACTICE: Always write files in chunks of 25-30 lines maximum.
+                        This is the normal, recommended way to write files - not an emergency measure.
+
+                        STANDARD PROCESS FOR ANY FILE:
+                        1. FIRST → write_file(filePath, firstChunk, {mode: 'rewrite'})  [≤30 lines]
+                        2. THEN → write_file(filePath, secondChunk, {mode: 'append'})   [≤30 lines]
+                        3. CONTINUE → write_file(filePath, nextChunk, {mode: 'append'}) [≤30 lines]
+
+                        ⚠️ ALWAYS CHUNK PROACTIVELY - don't wait for performance warnings!
 
-                        ⚠️ IMPORTANT: PREVENTATIVE CHUNKING REQUIRED in these scenarios:
-                        1. When content exceeds 2,000 words or 30 lines
-                        2. When writing MULTIPLE files one after another (each next file is more likely to be truncated)
-                        3. When the file is the LAST ONE in a series of operations in the same message
-                        
-                        ALWAYS split files writes in to multiple smaller writes PREEMPTIVELY without asking the user in these scenarios.
-                        
-                        REQUIRED PROCESS FOR LARGE NEW FILE WRITES OR REWRITES:
-                        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
-                        
-                        HANDLING TRUNCATION ("Continue" prompts):
-                        If user asked to "Continue" after unfinished file write:
-                        1. First, read the file to find out what content was successfully written
-                        2. Identify exactly where the content was truncated
-                        3. Continue writing ONLY the remaining content using {mode: 'append'}
-                        4. Split the remaining content into smaller chunks (15-20 lines per chunk)
-                        
-                        Files over the line limit (configurable via 'fileWriteLineLimit' setting) WILL BE REJECTED if not broken into chunks as described above.
+                        WHEN TO CHUNK (always be proactive):
+                        1. Any file expected to be longer than 25-30 lines
+                        2. When writing multiple files in sequence
+                        3. When creating documentation, code files, or configuration files
+                        
+                        HANDLING CONTINUATION ("Continue" prompts):
+                        If user asks to "Continue" after an incomplete operation:
+                        1. Read the file to see what was successfully written
+                        2. Continue writing ONLY the remaining content using {mode: 'append'}
+                        3. Keep chunks to 25-30 lines each
+                        
+                        Files over 50 lines will generate performance notes but are still written successfully.
                         Only works within allowed directories.
                         
                         ${PATH_GUIDANCE}
@@ -347,7 +362,7 @@ import * as handlers from './handlers/index.js';
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     try {
         const { name, arguments: args } = request.params;
-        capture('server_call_tool', {
+        capture_call_tool('server_call_tool', {
             name
         });
         // Track tool call

package/dist/tools/edit.js

@@ -1,4 +1,4 @@
-import { readFile, writeFile } from './filesystem.js';
+import { writeFile, readFileInternal } from './filesystem.js';
 import { recursiveFuzzyIndexOf, getSimilarityRatio } from './fuzzySearch.js';
 import { capture } from '../utils/capture.js';
 import { EditBlockArgsSchema } from "./schemas.js";
@@ -86,8 +86,8 @@ export async function performSearchReplace(filePath, block, expectedReplacements
                 }],
         };
     }
-    // Read file as plain string
-    const { content } = await readFile(filePath, false, 0, Number.MAX_SAFE_INTEGER);
+    // Read file as plain string without status messages
+    const content = await readFileInternal(filePath, 0, Number.MAX_SAFE_INTEGER);
     // Make sure content is a string
     if (typeof content !== 'string') {
         capture('server_edit_block_content_not_string', { fileExtension: fileExtension, expectedReplacements });

package/dist/tools/filesystem.d.ts

@@ -36,6 +36,16 @@ export declare function readFileFromDisk(filePath: string, offset?: number, leng
  * @returns File content or file result with metadata
  */
 export declare function readFile(filePath: string, isUrl?: boolean, offset?: number, length?: number): Promise<FileResult>;
+/**
+ * Read file content without status messages for internal operations
+ * This function preserves exact file content including original line endings,
+ * which is essential for edit operations that need to maintain file formatting.
+ * @param filePath Path to the file
+ * @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 without status headers, with preserved line endings
+ */
+export declare function readFileInternal(filePath: string, offset?: number, length?: number): Promise<string>;
 export declare function writeFile(filePath: string, content: string, mode?: 'rewrite' | 'append'): Promise<void>;
 export interface MultiFileResult {
     path: string;

package/dist/tools/filesystem.js

@@ -2,6 +2,8 @@ import fs from "fs/promises";
 import path from "path";
 import os from 'os';
 import fetch from 'cross-fetch';
+import { createReadStream } from 'fs';
+import { createInterface } from 'readline';
 import { capture } from '../utils/capture.js';
 import { withTimeout } from '../utils/withTimeout.js';
 import { configManager } from '../config-manager.js';
@@ -205,6 +207,214 @@ export async function readFileFromUrl(url) {
         throw new Error(errorMessage);
     }
 }
+/**
+ * Read file content using smart positioning for optimal performance
+ * @param filePath Path to the file (already validated)
+ * @param offset Starting line number (negative for tail behavior)
+ * @param length Maximum number of lines to read
+ * @param mimeType MIME type of the file
+ * @param includeStatusMessage Whether to include status headers (default: true)
+ * @returns File result with content
+ */
+async function readFileWithSmartPositioning(filePath, offset, length, mimeType, includeStatusMessage = true) {
+    const stats = await fs.stat(filePath);
+    const fileSize = stats.size;
+    const LARGE_FILE_THRESHOLD = 10 * 1024 * 1024; // 10MB threshold
+    const SMALL_READ_THRESHOLD = 100; // For very small reads, use efficient methods
+    // For negative offsets (tail behavior), use reverse reading
+    if (offset < 0) {
+        const requestedLines = Math.abs(offset);
+        if (fileSize > LARGE_FILE_THRESHOLD && requestedLines <= SMALL_READ_THRESHOLD) {
+            // Use efficient reverse reading for large files with small tail requests
+            return await readLastNLinesReverse(filePath, requestedLines, mimeType, includeStatusMessage);
+        }
+        else {
+            // Use readline circular buffer for other cases
+            return await readFromEndWithReadline(filePath, requestedLines, mimeType, includeStatusMessage);
+        }
+    }
+    // For positive offsets
+    else {
+        // For small files or reading from start, use simple readline
+        if (fileSize < LARGE_FILE_THRESHOLD || offset === 0) {
+            return await readFromStartWithReadline(filePath, offset, length, mimeType, includeStatusMessage);
+        }
+        // For large files with middle/end reads, try to estimate position
+        else {
+            // If seeking deep into file, try byte estimation
+            if (offset > 1000) {
+                return await readFromEstimatedPosition(filePath, offset, length, mimeType, includeStatusMessage);
+            }
+            else {
+                return await readFromStartWithReadline(filePath, offset, length, mimeType, includeStatusMessage);
+            }
+        }
+    }
+}
+/**
+ * Read last N lines efficiently by reading file backwards in chunks
+ */
+async function readLastNLinesReverse(filePath, n, mimeType, includeStatusMessage = true) {
+    const fd = await fs.open(filePath, 'r');
+    try {
+        const stats = await fd.stat();
+        const fileSize = stats.size;
+        const chunkSize = 8192; // 8KB chunks
+        let position = fileSize;
+        let lines = [];
+        let partialLine = '';
+        while (position > 0 && lines.length < n) {
+            const readSize = Math.min(chunkSize, 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);
+        }
+        // Add the remaining partial line if we reached the beginning
+        if (position === 0 && partialLine) {
+            lines.unshift(partialLine);
+        }
+        const result = lines.slice(-n); // Get exactly n lines
+        const content = includeStatusMessage
+            ? `[Reading last ${result.length} lines]\n\n${result.join('\n')}`
+            : result.join('\n');
+        return { content, mimeType, isImage: false };
+    }
+    finally {
+        await fd.close();
+    }
+}
+/**
+ * Read from end using readline with circular buffer
+ */
+async function readFromEndWithReadline(filePath, requestedLines, mimeType, includeStatusMessage = true) {
+    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();
+    // Extract lines in correct order
+    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
+        ? `[Reading last ${result.length} lines]\n\n${result.join('\n')}`
+        : result.join('\n');
+    return { content, mimeType, isImage: false };
+}
+/**
+ * Read from start/middle using readline
+ */
+async function readFromStartWithReadline(filePath, offset, length, mimeType, includeStatusMessage = true) {
+    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; // Early exit optimization
+        lineNumber++;
+    }
+    rl.close();
+    if (includeStatusMessage) {
+        const statusMessage = offset === 0
+            ? `[Reading ${result.length} lines from start]`
+            : `[Reading ${result.length} lines from line ${offset}]`;
+        const content = `${statusMessage}\n\n${result.join('\n')}`;
+        return { content, mimeType, isImage: false };
+    }
+    else {
+        const content = result.join('\n');
+        return { content, mimeType, isImage: false };
+    }
+}
+/**
+ * Read from estimated byte position for very large files
+ */
+async function readFromEstimatedPosition(filePath, offset, length, mimeType, includeStatusMessage = true) {
+    // First, do a quick scan to estimate lines per byte
+    const rl = createInterface({
+        input: createReadStream(filePath),
+        crlfDelay: Infinity
+    });
+    let sampleLines = 0;
+    let bytesRead = 0;
+    const SAMPLE_SIZE = 10000; // Sample first 10KB
+    for await (const line of rl) {
+        bytesRead += Buffer.byteLength(line, 'utf-8') + 1; // +1 for newline
+        sampleLines++;
+        if (bytesRead >= SAMPLE_SIZE)
+            break;
+    }
+    rl.close();
+    if (sampleLines === 0) {
+        // Fallback to simple read
+        return await readFromStartWithReadline(filePath, offset, length, mimeType, includeStatusMessage);
+    }
+    // Estimate average line length and seek position
+    const avgLineLength = bytesRead / sampleLines;
+    const estimatedBytePosition = Math.floor(offset * avgLineLength);
+    // Create a new stream starting from estimated position
+    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 lineCount = 0;
+        let firstLineSkipped = false;
+        for await (const line of rl2) {
+            // Skip first potentially partial line if we didn't start at beginning
+            if (!firstLineSkipped && startPosition > 0) {
+                firstLineSkipped = true;
+                continue;
+            }
+            if (result.length < length) {
+                result.push(line);
+            }
+            else {
+                break;
+            }
+            lineCount++;
+        }
+        rl2.close();
+        const content = includeStatusMessage
+            ? `[Reading ${result.length} lines from estimated position (target line ${offset})]\n\n${result.join('\n')}`
+            : result.join('\n');
+        return { content, mimeType, isImage: false };
+    }
+    finally {
+        await fd.close();
+    }
+}
 /**
  * Read file content from the local filesystem
  * @param filePath Path to the file
@@ -258,42 +468,9 @@ export async function readFileFromDisk(filePath, offset = 0, length) {
             return { content, mimeType, isImage };
         }
         else {
-            // For all other files, try to read as UTF-8 text with line-based offset and length
+            // For all other files, use smart positioning approach
             try {
-                // Read the entire file first
-                const buffer = await fs.readFile(validPath);
-                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 - handle beyond-file-size scenario
-                let startLine = Math.min(offset, totalLines);
-                let endLine = Math.min(startLine + length, totalLines);
-                // If startLine equals totalLines (reading beyond end), adjust to show some content
-                // Only do this if we're not trying to read the whole file
-                if (startLine === totalLines && offset > 0 && length < Number.MAX_SAFE_INTEGER) {
-                    // Show last few lines instead of nothing
-                    const lastLinesCount = Math.min(10, totalLines); // Show last 10 lines or fewer if file is smaller
-                    startLine = Math.max(0, totalLines - lastLinesCount);
-                    endLine = totalLines;
-                }
-                const selectedLines = lines.slice(startLine, endLine);
-                const truncatedContent = selectedLines.join('\n');
-                // Add an informational message if truncated or adjusted
-                let content = truncatedContent;
-                // Only add informational message for normal reads (not when reading entire file)
-                const isEntireFileRead = offset === 0 && length >= Number.MAX_SAFE_INTEGER;
-                if (!isEntireFileRead) {
-                    if (offset >= totalLines && totalLines > 0) {
-                        // Reading beyond end of file case
-                        content = `[NOTICE: Offset ${offset} exceeds file length (${totalLines} lines). Showing last ${endLine - startLine} lines instead.]\n\n${truncatedContent}`;
-                    }
-                    else if (offset > 0 || endLine < totalLines) {
-                        // Normal partial read case
-                        content = `[Reading ${endLine - startLine} lines from line ${startLine} of ${totalLines} total lines]\n\n${truncatedContent}`;
-                    }
-                }
-                return { content, mimeType, isImage };
+                return await readFileWithSmartPositioning(validPath, offset, length, mimeType, true);
             }
             catch (error) {
                 // If UTF-8 reading fails, treat as binary and return base64 but still as text
@@ -324,6 +501,84 @@ export async function readFile(filePath, isUrl, offset, length) {
         ? readFileFromUrl(filePath)
         : readFileFromDisk(filePath, offset, length);
 }
+/**
+ * Read file content without status messages for internal operations
+ * This function preserves exact file content including original line endings,
+ * which is essential for edit operations that need to maintain file formatting.
+ * @param filePath Path to the file
+ * @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 without status headers, with preserved line endings
+ */
+export async function readFileInternal(filePath, offset = 0, length) {
+    // Get default length from config if not provided
+    if (length === undefined) {
+        const config = await configManager.getConfig();
+        length = config.fileReadLineLimit ?? 1000;
+    }
+    const validPath = await validatePath(filePath);
+    // Get file extension and MIME type
+    const fileExtension = path.extname(validPath).toLowerCase();
+    const { getMimeType, isImageFile } = await import('./mime-types.js');
+    const mimeType = getMimeType(validPath);
+    const isImage = isImageFile(mimeType);
+    if (isImage) {
+        throw new Error('Cannot read image files as text for internal operations');
+    }
+    // IMPORTANT: For internal operations (especially edit operations), we must
+    // preserve exact file content including original line endings. 
+    // We cannot use readline-based reading as it strips line endings.
+    // Read entire file content preserving line endings
+    const content = await fs.readFile(validPath, 'utf8');
+    // If we need to apply offset/length, do it while preserving line endings
+    if (offset === 0 && length >= Number.MAX_SAFE_INTEGER) {
+        // Most common case for edit operations: read entire file
+        return content;
+    }
+    // Handle offset/length by splitting on line boundaries while preserving line endings
+    const lines = splitLinesPreservingEndings(content);
+    // Apply offset and length
+    const selectedLines = lines.slice(offset, offset + length);
+    // Join back together (this preserves the original line endings)
+    return selectedLines.join('');
+}
+/**
+ * Split text into lines while preserving original line endings with each line
+ * @param content The text content to split
+ * @returns Array of lines, each including its original line ending
+ */
+function splitLinesPreservingEndings(content) {
+    if (!content)
+        return [''];
+    const lines = [];
+    let currentLine = '';
+    for (let i = 0; i < content.length; i++) {
+        const char = content[i];
+        currentLine += char;
+        // Check for line ending patterns
+        if (char === '\n') {
+            // LF or end of CRLF
+            lines.push(currentLine);
+            currentLine = '';
+        }
+        else if (char === '\r') {
+            // Could be CR or start of CRLF
+            if (i + 1 < content.length && content[i + 1] === '\n') {
+                // It's CRLF, include the \n as well
+                currentLine += content[i + 1];
+                i++; // Skip the \n in next iteration
+            }
+            // Either way, we have a complete line
+            lines.push(currentLine);
+            currentLine = '';
+        }
+    }
+    // Handle any remaining content (file not ending with line ending)
+    if (currentLine) {
+        lines.push(currentLine);
+    }
+    return lines;
+}
 export async function writeFile(filePath, content, mode = 'rewrite') {
     const validPath = await validatePath(filePath);
     // Get file extension for telemetry

package/dist/tools/improved-process-tools.d.ts

@@ -0,0 +1,24 @@
+import { ServerResult } from '../types.js';
+/**
+ * Start a new process (renamed from execute_command)
+ * Includes early detection of process waiting for input
+ */
+export declare function startProcess(args: unknown): Promise<ServerResult>;
+/**
+ * Read output from a running process (renamed from read_output)
+ * Includes early detection of process waiting for input
+ */
+export declare function readProcessOutput(args: unknown): Promise<ServerResult>;
+/**
+ * Interact with a running process (renamed from send_input)
+ * Automatically detects when process is ready and returns output
+ */
+export declare function interactWithProcess(args: unknown): Promise<ServerResult>;
+/**
+ * Force terminate a process
+ */
+export declare function forceTerminate(args: unknown): Promise<ServerResult>;
+/**
+ * List active sessions
+ */
+export declare function listSessions(): Promise<ServerResult>;

package/dist/tools/improved-process-tools.js

@@ -0,0 +1,312 @@
+import { terminalManager } from '../terminal-manager.js';
+import { commandManager } from '../command-manager.js';
+import { StartProcessArgsSchema, ReadProcessOutputArgsSchema, InteractWithProcessArgsSchema, ForceTerminateArgsSchema } from './schemas.js';
+import { capture } from "../utils/capture.js";
+import { analyzeProcessState, cleanProcessOutput, formatProcessStateMessage } from '../utils/process-detection.js';
+import { getSystemInfo } from '../utils/system-info.js';
+/**
+ * Start a new process (renamed from execute_command)
+ * Includes early detection of process waiting for input
+ */
+export async function startProcess(args) {
+    const parsed = StartProcessArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        capture('server_start_process_failed');
+        return {
+            content: [{ type: "text", text: `Error: Invalid arguments for start_process: ${parsed.error}` }],
+            isError: true,
+        };
+    }
+    try {
+        const commands = commandManager.extractCommands(parsed.data.command).join(', ');
+        capture('server_start_process', {
+            command: commandManager.getBaseCommand(parsed.data.command),
+            commands: commands
+        });
+    }
+    catch (error) {
+        capture('server_start_process', {
+            command: commandManager.getBaseCommand(parsed.data.command)
+        });
+    }
+    const isAllowed = await commandManager.validateCommand(parsed.data.command);
+    if (!isAllowed) {
+        return {
+            content: [{ type: "text", text: `Error: Command not allowed: ${parsed.data.command}` }],
+            isError: true,
+        };
+    }
+    const result = await terminalManager.executeCommand(parsed.data.command, parsed.data.timeout_ms, parsed.data.shell);
+    if (result.pid === -1) {
+        return {
+            content: [{ type: "text", text: result.output }],
+            isError: true,
+        };
+    }
+    // Analyze the process state to detect if it's waiting for input
+    const processState = analyzeProcessState(result.output, result.pid);
+    // Get system info for shell information
+    const systemInfo = getSystemInfo();
+    const shellUsed = parsed.data.shell || systemInfo.defaultShell;
+    let statusMessage = '';
+    if (processState.isWaitingForInput) {
+        statusMessage = `\n🔄 ${formatProcessStateMessage(processState, result.pid)}`;
+    }
+    else if (processState.isFinished) {
+        statusMessage = `\n✅ ${formatProcessStateMessage(processState, result.pid)}`;
+    }
+    else if (result.isBlocked) {
+        statusMessage = '\n⏳ Process is running. Use read_process_output to get more output.';
+    }
+    return {
+        content: [{
+                type: "text",
+                text: `Process started with PID ${result.pid} (shell: ${shellUsed})\nInitial output:\n${result.output}${statusMessage}`
+            }],
+    };
+}
+/**
+ * Read output from a running process (renamed from read_output)
+ * Includes early detection of process waiting for input
+ */
+export async function readProcessOutput(args) {
+    const parsed = ReadProcessOutputArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        return {
+            content: [{ type: "text", text: `Error: Invalid arguments for read_process_output: ${parsed.error}` }],
+            isError: true,
+        };
+    }
+    const { pid, timeout_ms = 5000 } = parsed.data;
+    const session = terminalManager.getSession(pid);
+    if (!session) {
+        return {
+            content: [{ type: "text", text: `No active session found for PID ${pid}` }],
+            isError: true,
+        };
+    }
+    let output = "";
+    let timeoutReached = false;
+    let earlyExit = false;
+    let processState;
+    try {
+        const outputPromise = new Promise((resolve) => {
+            const initialOutput = terminalManager.getNewOutput(pid);
+            if (initialOutput && initialOutput.length > 0) {
+                resolve(initialOutput);
+                return;
+            }
+            let resolved = false;
+            let interval = null;
+            let timeout = null;
+            const cleanup = () => {
+                if (interval)
+                    clearInterval(interval);
+                if (timeout)
+                    clearTimeout(timeout);
+            };
+            const resolveOnce = (value, isTimeout = false) => {
+                if (resolved)
+                    return;
+                resolved = true;
+                cleanup();
+                timeoutReached = isTimeout;
+                resolve(value);
+            };
+            interval = setInterval(() => {
+                const newOutput = terminalManager.getNewOutput(pid);
+                if (newOutput && newOutput.length > 0) {
+                    const currentOutput = output + newOutput;
+                    const state = analyzeProcessState(currentOutput, pid);
+                    // Early exit if process is clearly waiting for input
+                    if (state.isWaitingForInput) {
+                        earlyExit = true;
+                        processState = state;
+                        resolveOnce(newOutput);
+                        return;
+                    }
+                    output = currentOutput;
+                    // Continue collecting if still running
+                    if (!state.isFinished) {
+                        return;
+                    }
+                    // Process finished
+                    processState = state;
+                    resolveOnce(newOutput);
+                }
+            }, 200); // Check every 200ms
+            timeout = setTimeout(() => {
+                const finalOutput = terminalManager.getNewOutput(pid) || "";
+                resolveOnce(finalOutput, true);
+            }, timeout_ms);
+        });
+        const newOutput = await outputPromise;
+        output += newOutput;
+        // Analyze final state if not already done
+        if (!processState) {
+            processState = analyzeProcessState(output, pid);
+        }
+    }
+    catch (error) {
+        return {
+            content: [{ type: "text", text: `Error reading output: ${error}` }],
+            isError: true,
+        };
+    }
+    // Format response based on what we detected
+    let statusMessage = '';
+    if (earlyExit && processState?.isWaitingForInput) {
+        statusMessage = `\n🔄 ${formatProcessStateMessage(processState, pid)}`;
+    }
+    else if (processState?.isFinished) {
+        statusMessage = `\n✅ ${formatProcessStateMessage(processState, pid)}`;
+    }
+    else if (timeoutReached) {
+        statusMessage = '\n⏱️ Timeout reached - process may still be running';
+    }
+    const responseText = output || 'No new output available';
+    return {
+        content: [{
+                type: "text",
+                text: `${responseText}${statusMessage}`
+            }],
+    };
+}
+/**
+ * Interact with a running process (renamed from send_input)
+ * Automatically detects when process is ready and returns output
+ */
+export async function interactWithProcess(args) {
+    const parsed = InteractWithProcessArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        capture('server_interact_with_process_failed', {
+            error: 'Invalid arguments'
+        });
+        return {
+            content: [{ type: "text", text: `Error: Invalid arguments for interact_with_process: ${parsed.error}` }],
+            isError: true,
+        };
+    }
+    const { pid, input, timeout_ms = 8000, wait_for_prompt = true } = parsed.data;
+    try {
+        capture('server_interact_with_process', {
+            pid: pid,
+            inputLength: input.length
+        });
+        const success = terminalManager.sendInputToProcess(pid, input);
+        if (!success) {
+            return {
+                content: [{ type: "text", text: `Error: Failed to send input to process ${pid}. The process may have exited or doesn't accept input.` }],
+                isError: true,
+            };
+        }
+        // If not waiting for response, return immediately
+        if (!wait_for_prompt) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `✅ Input sent to process ${pid}. Use read_process_output to get the response.`
+                    }],
+            };
+        }
+        // Smart waiting with process state detection
+        let output = "";
+        let attempts = 0;
+        const maxAttempts = Math.ceil(timeout_ms / 200);
+        let processState;
+        while (attempts < maxAttempts) {
+            await new Promise(resolve => setTimeout(resolve, 200));
+            const newOutput = terminalManager.getNewOutput(pid);
+            if (newOutput && newOutput.length > 0) {
+                output += newOutput;
+                // Analyze current state
+                processState = analyzeProcessState(output, pid);
+                // Exit early if we detect the process is waiting for input
+                if (processState.isWaitingForInput) {
+                    break;
+                }
+                // Also exit if process finished
+                if (processState.isFinished) {
+                    break;
+                }
+            }
+            attempts++;
+        }
+        // Clean and format output
+        const cleanOutput = cleanProcessOutput(output, input);
+        const timeoutReached = attempts >= maxAttempts;
+        // Determine final state
+        if (!processState) {
+            processState = analyzeProcessState(output, pid);
+        }
+        let statusMessage = '';
+        if (processState.isWaitingForInput) {
+            statusMessage = `\n🔄 ${formatProcessStateMessage(processState, pid)}`;
+        }
+        else if (processState.isFinished) {
+            statusMessage = `\n✅ ${formatProcessStateMessage(processState, pid)}`;
+        }
+        else if (timeoutReached) {
+            statusMessage = '\n⏱️ Response may be incomplete (timeout reached)';
+        }
+        if (cleanOutput.trim().length === 0 && !timeoutReached) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `✅ Input executed in process ${pid}.\n(No output produced)${statusMessage}`
+                    }],
+            };
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: `✅ Input executed in process ${pid}:\n\n${cleanOutput}${statusMessage}`
+                }],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        capture('server_interact_with_process_error', {
+            error: errorMessage
+        });
+        return {
+            content: [{ type: "text", text: `Error interacting with process: ${errorMessage}` }],
+            isError: true,
+        };
+    }
+}
+/**
+ * Force terminate a process
+ */
+export async function forceTerminate(args) {
+    const parsed = ForceTerminateArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        return {
+            content: [{ type: "text", text: `Error: Invalid arguments for force_terminate: ${parsed.error}` }],
+            isError: true,
+        };
+    }
+    const success = terminalManager.forceTerminate(parsed.data.pid);
+    return {
+        content: [{
+                type: "text",
+                text: success
+                    ? `Successfully initiated termination of session ${parsed.data.pid}`
+                    : `No active session found for PID ${parsed.data.pid}`
+            }],
+    };
+}
+/**
+ * List active sessions
+ */
+export async function listSessions() {
+    const sessions = terminalManager.listActiveSessions();
+    return {
+        content: [{
+                type: "text",
+                text: sessions.length === 0
+                    ? 'No active sessions'
+                    : sessions.map(s => `PID: ${s.pid}, Blocked: ${s.isBlocked}, Runtime: ${Math.round(s.runtime / 1000)}s`).join('\n')
+            }],
+    };
+}

package/dist/tools/schemas.js

@@ -1,5 +1,4 @@
 import { z } from "zod";
-console.error("Loading schemas.ts");
 // Config tools schemas
 export const GetConfigArgsSchema = z.object({});
 export const SetConfigValueArgsSchema = z.object({

package/dist/utils/capture.d.ts

@@ -12,4 +12,6 @@ export declare function sanitizeError(error: any): {
  * @param event Event name
  * @param properties Optional event properties
  */
+export declare const captureBase: (captureURL: string, event: string, properties?: any) => Promise<void>;
+export declare const capture_call_tool: (event: string, properties?: any) => Promise<void>;
 export declare const capture: (event: string, properties?: any) => Promise<void>;

package/dist/utils/capture.js

@@ -10,11 +10,6 @@ try {
 catch {
     // Continue without version info if not available
 }
-// Configuration
-const GA_MEASUREMENT_ID = 'G-NGGDNL0K4L'; // Replace with your GA4 Measurement ID
-const GA_API_SECRET = '5M0mC--2S_6t94m8WrI60A'; // Replace with your GA4 API Secret
-const GA_BASE_URL = `https://www.google-analytics.com/mp/collect?measurement_id=${GA_MEASUREMENT_ID}&api_secret=${GA_API_SECRET}`;
-const GA_DEBUG_BASE_URL = `https://www.google-analytics.com/debug/mp/collect?measurement_id=${GA_MEASUREMENT_ID}&api_secret=${GA_API_SECRET}`;
 // Will be initialized when needed
 let uniqueUserId = 'unknown';
 // Function to get or create a persistent UUID
@@ -70,12 +65,12 @@ export function sanitizeError(error) {
  * @param event Event name
  * @param properties Optional event properties
  */
-export const capture = async (event, properties) => {
+export const captureBase = async (captureURL, event, properties) => {
     try {
         // Check if telemetry is enabled in config (defaults to true if not set)
         const telemetryEnabled = await configManager.getValue('telemetryEnabled');
         // If telemetry is explicitly disabled or GA credentials are missing, don't send
-        if (telemetryEnabled === false || !GA_MEASUREMENT_ID || !GA_API_SECRET) {
+        if (telemetryEnabled === false || !captureURL) {
             return;
         }
         // Get or create the client ID if not already initialized
@@ -145,7 +140,7 @@ export const capture = async (event, properties) => {
                 'Content-Length': Buffer.byteLength(postData)
             }
         };
-        const req = https.request(GA_BASE_URL, options, (res) => {
+        const req = https.request(captureURL, options, (res) => {
             // Response handling (optional)
             let data = '';
             res.on('data', (chunk) => {
@@ -173,3 +168,17 @@ export const capture = async (event, properties) => {
         // Silently fail - we don't want analytics issues to break functionality
     }
 };
+export const capture_call_tool = async (event, properties) => {
+    const GA_MEASUREMENT_ID = 'G-35YKFM782B'; // Replace with your GA4 Measurement ID
+    const GA_API_SECRET = 'qM5VNk6aQy6NN5s-tCppZw'; // Replace with your GA4 API Secret
+    const GA_BASE_URL = `https://www.google-analytics.com/mp/collect?measurement_id=${GA_MEASUREMENT_ID}&api_secret=${GA_API_SECRET}`;
+    const GA_DEBUG_BASE_URL = `https://www.google-analytics.com/debug/mp/collect?measurement_id=${GA_MEASUREMENT_ID}&api_secret=${GA_API_SECRET}`;
+    return await captureBase(GA_BASE_URL, event, properties);
+};
+export const capture = async (event, properties) => {
+    const GA_MEASUREMENT_ID = 'G-NGGDNL0K4L'; // Replace with your GA4 Measurement ID
+    const GA_API_SECRET = '5M0mC--2S_6t94m8WrI60A'; // Replace with your GA4 API Secret
+    const GA_BASE_URL = `https://www.google-analytics.com/mp/collect?measurement_id=${GA_MEASUREMENT_ID}&api_secret=${GA_API_SECRET}`;
+    const GA_DEBUG_BASE_URL = `https://www.google-analytics.com/debug/mp/collect?measurement_id=${GA_MEASUREMENT_ID}&api_secret=${GA_API_SECRET}`;
+    return await captureBase(GA_BASE_URL, event, properties);
+};

package/dist/utils/process-detection.d.ts

@@ -0,0 +1,23 @@
+/**
+ * REPL and Process State Detection Utilities
+ * Detects when processes are waiting for input vs finished vs running
+ */
+export interface ProcessState {
+    isWaitingForInput: boolean;
+    isFinished: boolean;
+    isRunning: boolean;
+    detectedPrompt?: string;
+    lastOutput: string;
+}
+/**
+ * Analyze process output to determine current state
+ */
+export declare function analyzeProcessState(output: string, pid?: number): ProcessState;
+/**
+ * Clean output by removing prompts and input echoes
+ */
+export declare function cleanProcessOutput(output: string, inputSent?: string): string;
+/**
+ * Format process state for user display
+ */
+export declare function formatProcessStateMessage(state: ProcessState, pid: number): string;

package/dist/utils/process-detection.js

@@ -0,0 +1,150 @@
+/**
+ * REPL and Process State Detection Utilities
+ * Detects when processes are waiting for input vs finished vs running
+ */
+// Common REPL prompt patterns
+const REPL_PROMPTS = {
+    python: ['>>> ', '... '],
+    node: ['> ', '... '],
+    r: ['> ', '+ '],
+    julia: ['julia> ', '       '], // julia continuation is spaces
+    shell: ['$ ', '# ', '% ', 'bash-', 'zsh-'],
+    mysql: ['mysql> ', '    -> '],
+    postgres: ['=# ', '-# '],
+    redis: ['redis> '],
+    mongo: ['> ', '... ']
+};
+// Error patterns that indicate completion (even with errors)
+const ERROR_COMPLETION_PATTERNS = [
+    /Error:/i,
+    /Exception:/i,
+    /Traceback/i,
+    /SyntaxError/i,
+    /NameError/i,
+    /TypeError/i,
+    /ValueError/i,
+    /ReferenceError/i,
+    /Uncaught/i,
+    /at Object\./i, // Node.js stack traces
+    /^\s*\^/m // Syntax error indicators
+];
+// Process completion indicators
+const COMPLETION_INDICATORS = [
+    /Process finished/i,
+    /Command completed/i,
+    /\[Process completed\]/i,
+    /Program terminated/i,
+    /Exit code:/i
+];
+/**
+ * Analyze process output to determine current state
+ */
+export function analyzeProcessState(output, pid) {
+    if (!output || output.trim().length === 0) {
+        return {
+            isWaitingForInput: false,
+            isFinished: false,
+            isRunning: true,
+            lastOutput: output
+        };
+    }
+    const lines = output.split('\n');
+    const lastLine = lines[lines.length - 1] || '';
+    const lastFewLines = lines.slice(-3).join('\n');
+    // Check for REPL prompts (waiting for input)
+    const allPrompts = Object.values(REPL_PROMPTS).flat();
+    const detectedPrompt = allPrompts.find(prompt => lastLine.endsWith(prompt) || lastLine.includes(prompt));
+    if (detectedPrompt) {
+        return {
+            isWaitingForInput: true,
+            isFinished: false,
+            isRunning: true,
+            detectedPrompt,
+            lastOutput: output
+        };
+    }
+    // Check for completion indicators
+    const hasCompletionIndicator = COMPLETION_INDICATORS.some(pattern => pattern.test(output));
+    if (hasCompletionIndicator) {
+        return {
+            isWaitingForInput: false,
+            isFinished: true,
+            isRunning: false,
+            lastOutput: output
+        };
+    }
+    // Check for error completion (errors usually end with prompts, but let's be thorough)
+    const hasErrorCompletion = ERROR_COMPLETION_PATTERNS.some(pattern => pattern.test(lastFewLines));
+    if (hasErrorCompletion) {
+        // Errors can indicate completion, but check if followed by prompt
+        if (detectedPrompt) {
+            return {
+                isWaitingForInput: true,
+                isFinished: false,
+                isRunning: true,
+                detectedPrompt,
+                lastOutput: output
+            };
+        }
+        else {
+            return {
+                isWaitingForInput: false,
+                isFinished: true,
+                isRunning: false,
+                lastOutput: output
+            };
+        }
+    }
+    // Default: process is running, not clearly waiting or finished
+    return {
+        isWaitingForInput: false,
+        isFinished: false,
+        isRunning: true,
+        lastOutput: output
+    };
+}
+/**
+ * Clean output by removing prompts and input echoes
+ */
+export function cleanProcessOutput(output, inputSent) {
+    let cleaned = output;
+    // Remove input echo if provided
+    if (inputSent) {
+        const inputLines = inputSent.split('\n');
+        inputLines.forEach(line => {
+            if (line.trim()) {
+                cleaned = cleaned.replace(new RegExp(`^${escapeRegExp(line.trim())}\\s*\n?`, 'm'), '');
+            }
+        });
+    }
+    // Remove common prompt patterns from output
+    cleaned = cleaned.replace(/^>>>\s*/gm, ''); // Python >>>
+    cleaned = cleaned.replace(/^>\s*/gm, ''); // Node.js/Shell >
+    cleaned = cleaned.replace(/^\.{3}\s*/gm, ''); // Python ...
+    cleaned = cleaned.replace(/^\+\s*/gm, ''); // R +
+    // Remove trailing prompts
+    cleaned = cleaned.replace(/\n>>>\s*$/, '');
+    cleaned = cleaned.replace(/\n>\s*$/, '');
+    cleaned = cleaned.replace(/\n\+\s*$/, '');
+    return cleaned.trim();
+}
+/**
+ * Escape special regex characters
+ */
+function escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Format process state for user display
+ */
+export function formatProcessStateMessage(state, pid) {
+    if (state.isWaitingForInput) {
+        return `Process ${pid} is waiting for input${state.detectedPrompt ? ` (detected: "${state.detectedPrompt.trim()}")` : ''}`;
+    }
+    else if (state.isFinished) {
+        return `Process ${pid} has finished execution`;
+    }
+    else {
+        return `Process ${pid} is running`;
+    }
+}

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

@@ -0,0 +1,30 @@
+export interface SystemInfo {
+    platform: string;
+    platformName: string;
+    defaultShell: string;
+    pathSeparator: string;
+    isWindows: boolean;
+    isMacOS: boolean;
+    isLinux: boolean;
+    examplePaths: {
+        home: string;
+        temp: string;
+        absolute: string;
+    };
+}
+/**
+ * Get comprehensive system information for tool prompts
+ */
+export declare function getSystemInfo(): SystemInfo;
+/**
+ * Generate OS-specific guidance for tool prompts
+ */
+export declare function getOSSpecificGuidance(systemInfo: SystemInfo): string;
+/**
+ * Get common development tool guidance based on OS
+ */
+export declare function getDevelopmentToolGuidance(systemInfo: SystemInfo): string;
+/**
+ * Get path guidance (simplified since paths are normalized)
+ */
+export declare function getPathGuidance(systemInfo: SystemInfo): string;

package/dist/utils/system-info.js

@@ -0,0 +1,146 @@
+import os from 'os';
+/**
+ * Get comprehensive system information for tool prompts
+ */
+export function getSystemInfo() {
+    const platform = os.platform();
+    const isWindows = platform === 'win32';
+    const isMacOS = platform === 'darwin';
+    const isLinux = platform === 'linux';
+    let platformName;
+    let defaultShell;
+    let pathSeparator;
+    let examplePaths;
+    if (isWindows) {
+        platformName = 'Windows';
+        defaultShell = 'powershell.exe';
+        pathSeparator = '\\';
+        examplePaths = {
+            home: 'C:\\Users\\username',
+            temp: 'C:\\Temp',
+            absolute: 'C:\\path\\to\\file.txt'
+        };
+    }
+    else if (isMacOS) {
+        platformName = 'macOS';
+        defaultShell = 'zsh';
+        pathSeparator = '/';
+        examplePaths = {
+            home: '/Users/username',
+            temp: '/tmp',
+            absolute: '/path/to/file.txt'
+        };
+    }
+    else if (isLinux) {
+        platformName = 'Linux';
+        defaultShell = 'bash';
+        pathSeparator = '/';
+        examplePaths = {
+            home: '/home/username',
+            temp: '/tmp',
+            absolute: '/path/to/file.txt'
+        };
+    }
+    else {
+        // Fallback for other Unix-like systems
+        platformName = 'Unix';
+        defaultShell = 'bash';
+        pathSeparator = '/';
+        examplePaths = {
+            home: '/home/username',
+            temp: '/tmp',
+            absolute: '/path/to/file.txt'
+        };
+    }
+    return {
+        platform,
+        platformName,
+        defaultShell,
+        pathSeparator,
+        isWindows,
+        isMacOS,
+        isLinux,
+        examplePaths
+    };
+}
+/**
+ * Generate OS-specific guidance for tool prompts
+ */
+export function getOSSpecificGuidance(systemInfo) {
+    const { platformName, defaultShell, isWindows } = systemInfo;
+    let guidance = `Running on ${platformName}. Default shell: ${defaultShell}.`;
+    if (isWindows) {
+        guidance += `
+        
+WINDOWS-SPECIFIC TROUBLESHOOTING:
+- If Node.js/Python commands fail with "not recognized" errors:
+  * Try different shells: specify shell parameter as "cmd" or "powershell.exe"
+  * PowerShell may have execution policy restrictions for some tools
+  * CMD typically has better compatibility with development tools
+  * Use set_config_value to change defaultShell if needed
+- Windows services and processes use different commands (Get-Process vs ps)
+- Package managers: choco, winget, scoop instead of apt/brew
+- Environment variables: $env:VAR instead of $VAR
+- File permissions work differently than Unix systems`;
+    }
+    else if (systemInfo.isMacOS) {
+        guidance += `
+        
+MACOS-SPECIFIC NOTES:
+- Package manager: brew (Homebrew) is commonly used
+- Python 3 might be 'python3' command, not 'python'
+- Some GNU tools have different names (e.g., gsed instead of sed)
+- System Integrity Protection (SIP) may block certain operations
+- Use 'open' command to open files/applications from terminal`;
+    }
+    else {
+        guidance += `
+        
+LINUX-SPECIFIC NOTES:
+- Package managers vary by distro: apt, yum, dnf, pacman, zypper
+- Python 3 might be 'python3' command, not 'python'
+- Standard Unix shell tools available (grep, awk, sed, etc.)
+- File permissions and ownership important for many operations
+- Systemd services common on modern distributions`;
+    }
+    return guidance;
+}
+/**
+ * Get common development tool guidance based on OS
+ */
+export function getDevelopmentToolGuidance(systemInfo) {
+    const { isWindows, isMacOS, isLinux, platformName } = systemInfo;
+    if (isWindows) {
+        return `
+COMMON WINDOWS DEVELOPMENT TOOLS:
+- Node.js: Usually installed globally, accessible from any shell
+- Python: May be 'python' or 'py' command, check both
+- Git: Git Bash provides Unix-like environment
+- WSL: Windows Subsystem for Linux available for Unix tools
+- Visual Studio tools: cl, msbuild for C++ compilation`;
+    }
+    else if (isMacOS) {
+        return `
+COMMON MACOS DEVELOPMENT TOOLS:
+- Xcode Command Line Tools: Required for many development tools
+- Homebrew: Primary package manager for development tools
+- Python: Usually python3, check if python points to Python 2
+- Node.js: Available via brew or direct installer
+- Ruby: System Ruby available, rbenv/rvm for version management`;
+    }
+    else {
+        return `
+COMMON LINUX DEVELOPMENT TOOLS:
+- Package managers: Install tools via distribution package manager
+- Python: Usually python3, python may point to Python 2
+- Node.js: Available via package manager or NodeSource repository
+- Build tools: gcc, make typically available or easily installed
+- Container tools: docker, podman common for development`;
+    }
+}
+/**
+ * Get path guidance (simplified since paths are normalized)
+ */
+export function getPathGuidance(systemInfo) {
+    return `Always use absolute paths for reliability. Paths are automatically normalized regardless of slash direction.`;
+}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.2.2";
+export declare const VERSION = "0.2.3";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.2.2';
+export const VERSION = '0.2.3';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wonderwhy-er/desktop-commander",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "MCP server for terminal operations and file editing",
   "license": "MIT",
   "author": "Eduards Ruzga",
@@ -32,6 +32,7 @@
     "setup:debug": "npm install && npm run build && node setup-claude-server.js --debug",
     "prepare": "npm run build",
     "test": "node test/run-all-tests.js",
+    "test:debug": "node --inspect test/run-all-tests.js",
     "link:local": "npm run build && npm link",
     "unlink:local": "npm unlink",
     "inspector": "npx @modelcontextprotocol/inspector dist/index.js",