@wonderwhy-er/desktop-commander 0.2.23 → 0.2.24

package/dist/search-manager.js

@@ -1,8 +1,10 @@
 import { spawn } from 'child_process';
 import path from 'path';
+import fs from 'fs/promises';
 import { validatePath } from './tools/filesystem.js';
 import { capture } from './utils/capture.js';
 import { getRipgrepPath } from './utils/ripgrep-resolver.js';
+import { isExcelFile } from './utils/files/index.js';
 /**
  * Search Session Manager - handles ripgrep processes like terminal sessions
  * Supports both file search and content search with progressive results
@@ -85,7 +87,26 @@ import { getRipgrepPath } from './utils/ripgrep-resolver.js';
             requestedPath: options.rootPath,
             validatedPath: validPath
         });
+        // For content searches, only search Excel files when contextually relevant:
+        // - filePattern explicitly targets Excel files (*.xlsx, *.xls, etc.)
+        // - or rootPath is an Excel file itself
+        const shouldSearchExcel = options.searchType === 'content' &&
+            this.shouldIncludeExcelSearch(options.filePattern, validPath);
+        if (shouldSearchExcel) {
+            this.searchExcelFiles(validPath, options.pattern, options.ignoreCase !== false, options.maxResults, options.filePattern // Pass filePattern to filter Excel files too
+            ).then(excelResults => {
+                // Add Excel results to session (merged after initial response)
+                for (const result of excelResults) {
+                    session.results.push(result);
+                    session.totalMatches++;
+                }
+            }).catch((err) => {
+                // Log Excel search errors but don't fail the whole search
+                capture('excel_search_error', { error: err instanceof Error ? err.message : String(err) });
+            });
+        }
         // Wait for first chunk of data or early completion instead of fixed delay
+        // Excel search runs in background and results are merged via readSearchResults
         const firstChunk = new Promise(resolve => {
             const onData = () => {
                 session.process.stdout?.off('data', onData);
@@ -94,6 +115,7 @@ import { getRipgrepPath } from './utils/ripgrep-resolver.js';
             session.process.stdout?.once('data', onData);
             setTimeout(resolve, 40); // cap at 40ms instead of 50-100ms
         });
+        // Only wait for ripgrep first chunk - Excel results merge asynchronously
         await firstChunk;
         return {
             sessionId,
@@ -178,6 +200,170 @@ import { getRipgrepPath } from './utils/ripgrep-resolver.js';
             totalResults: session.totalMatches + session.totalContextLines
         }));
     }
+    /**
+     * Search Excel files for content matches
+     * Called during content search to include Excel files alongside text files
+     * Searches ALL sheets in each Excel file (row-wise for cross-column matching)
+     *
+     * TODO: Refactor - Extract Excel search logic to separate module (src/utils/search/excel-search.ts)
+     * and inject into SearchManager, similar to how file handlers are structured in src/utils/files/
+     * This would allow adding other file type searches (PDF, etc.) without bloating search-manager.ts
+     */
+    async searchExcelFiles(rootPath, pattern, ignoreCase, maxResults, filePattern) {
+        const results = [];
+        // Build regex for matching content
+        const flags = ignoreCase ? 'i' : '';
+        let regex;
+        try {
+            regex = new RegExp(pattern, flags);
+        }
+        catch {
+            // If pattern is not valid regex, escape it for literal matching
+            const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            regex = new RegExp(escaped, flags);
+        }
+        // Find Excel files recursively
+        let excelFiles = await this.findExcelFiles(rootPath);
+        // Filter by filePattern if provided
+        if (filePattern) {
+            const patterns = filePattern.split('|').map(p => p.trim()).filter(Boolean);
+            excelFiles = excelFiles.filter(filePath => {
+                const fileName = path.basename(filePath);
+                return patterns.some(pat => {
+                    // Support glob-like patterns
+                    if (pat.includes('*')) {
+                        const regexPat = pat.replace(/\./g, '\\.').replace(/\*/g, '.*');
+                        return new RegExp(`^${regexPat}$`, 'i').test(fileName);
+                    }
+                    // Exact match (case-insensitive)
+                    return fileName.toLowerCase() === pat.toLowerCase();
+                });
+            });
+        }
+        // Dynamically import ExcelJS to search all sheets
+        const ExcelJS = await import('exceljs');
+        for (const filePath of excelFiles) {
+            if (maxResults && results.length >= maxResults)
+                break;
+            try {
+                const workbook = new ExcelJS.default.Workbook();
+                await workbook.xlsx.readFile(filePath);
+                // Search ALL sheets in the workbook (row-wise for speed and cross-column matching)
+                for (const worksheet of workbook.worksheets) {
+                    if (maxResults && results.length >= maxResults)
+                        break;
+                    const sheetName = worksheet.name;
+                    // Iterate through rows (faster than cell-by-cell)
+                    worksheet.eachRow({ includeEmpty: false }, (row, rowNumber) => {
+                        if (maxResults && results.length >= maxResults)
+                            return;
+                        // Build a concatenated string of all cell values in the row
+                        const rowValues = [];
+                        row.eachCell({ includeEmpty: false }, (cell) => {
+                            if (cell.value === null || cell.value === undefined)
+                                return;
+                            let cellStr;
+                            if (typeof cell.value === 'object') {
+                                if ('result' in cell.value) {
+                                    cellStr = String(cell.value.result ?? '');
+                                }
+                                else if ('richText' in cell.value) {
+                                    cellStr = cell.value.richText.map((rt) => rt.text).join('');
+                                }
+                                else if ('text' in cell.value) {
+                                    cellStr = String(cell.value.text);
+                                }
+                                else {
+                                    cellStr = String(cell.value);
+                                }
+                            }
+                            else {
+                                cellStr = String(cell.value);
+                            }
+                            if (cellStr.trim()) {
+                                rowValues.push(cellStr);
+                            }
+                        });
+                        // Join all cell values with space for cross-column matching
+                        const rowText = rowValues.join(' ');
+                        if (regex.test(rowText)) {
+                            // Extract the matching portion for display
+                            const match = rowText.match(regex);
+                            const matchContext = match
+                                ? this.getMatchContext(rowText, match.index || 0, match[0].length)
+                                : rowText.substring(0, 150);
+                            results.push({
+                                file: `${filePath}:${sheetName}!Row${rowNumber}`,
+                                line: rowNumber,
+                                match: matchContext,
+                                type: 'content'
+                            });
+                        }
+                    });
+                }
+            }
+            catch (error) {
+                // Skip files that can't be read (permission issues, corrupted, etc.)
+                continue;
+            }
+        }
+        return results;
+    }
+    /**
+     * Find all Excel files in a directory recursively
+     */
+    async findExcelFiles(rootPath) {
+        const excelFiles = [];
+        async function walk(dir) {
+            try {
+                const entries = await fs.readdir(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = path.join(dir, entry.name);
+                    if (entry.isDirectory()) {
+                        // Skip node_modules, .git, etc.
+                        if (!entry.name.startsWith('.') && entry.name !== 'node_modules') {
+                            await walk(fullPath);
+                        }
+                    }
+                    else if (entry.isFile() && isExcelFile(entry.name)) {
+                        excelFiles.push(fullPath);
+                    }
+                }
+            }
+            catch {
+                // Skip directories we can't read
+            }
+        }
+        // Check if rootPath is a file or directory
+        try {
+            const stats = await fs.stat(rootPath);
+            if (stats.isFile() && isExcelFile(rootPath)) {
+                return [rootPath];
+            }
+            else if (stats.isDirectory()) {
+                await walk(rootPath);
+            }
+        }
+        catch {
+            // Path doesn't exist or can't be accessed
+        }
+        return excelFiles;
+    }
+    /**
+     * Extract context around a match for display (show surrounding text)
+     */
+    getMatchContext(text, matchStart, matchLength) {
+        const contextChars = 50; // chars before and after match
+        const start = Math.max(0, matchStart - contextChars);
+        const end = Math.min(text.length, matchStart + matchLength + contextChars);
+        let context = text.substring(start, end);
+        // Add ellipsis if truncated
+        if (start > 0)
+            context = '...' + context;
+        if (end < text.length)
+            context = context + '...';
+        return context;
+    }
     /**
      * Clean up completed sessions older than specified time
      * Called automatically by cleanup interval
@@ -215,6 +401,32 @@ import { getRipgrepPath } from './utils/ripgrep-resolver.js';
             pattern.includes(']') ||
             pattern.includes('}');
     }
+    /**
+     * Determine if Excel search should be included based on context
+     * Only searches Excel files when:
+     * - filePattern explicitly targets Excel files (*.xlsx, *.xls, *.xlsm, *.xlsb)
+     * - or the rootPath itself is an Excel file
+     */
+    shouldIncludeExcelSearch(filePattern, rootPath) {
+        const excelExtensions = ['.xlsx', '.xls', '.xlsm', '.xlsb'];
+        // Check if rootPath is an Excel file
+        if (rootPath) {
+            const lowerPath = rootPath.toLowerCase();
+            if (excelExtensions.some(ext => lowerPath.endsWith(ext))) {
+                return true;
+            }
+        }
+        // Check if filePattern targets Excel files
+        if (filePattern) {
+            const lowerPattern = filePattern.toLowerCase();
+            // Check for patterns like *.xlsx, *.xls, or explicit Excel extensions
+            if (excelExtensions.some(ext => lowerPattern.includes(`*${ext}`) ||
+                lowerPattern.endsWith(ext))) {
+                return true;
+            }
+        }
+        return false;
+    }
     buildRipgrepArgs(options) {
         const args = [];
         if (options.searchType === 'content') {

package/dist/server.js

@@ -8,7 +8,7 @@ const OS_GUIDANCE = getOSSpecificGuidance(SYSTEM_INFO);
 const DEV_TOOL_GUIDANCE = getDevelopmentToolGuidance(SYSTEM_INFO);
 const PATH_GUIDANCE = `IMPORTANT: ${getPathGuidance(SYSTEM_INFO)} 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 { StartProcessArgsSchema, ReadProcessOutputArgsSchema, InteractWithProcessArgsSchema, ForceTerminateArgsSchema, ListSessionsArgsSchema, KillProcessArgsSchema, ReadFileArgsSchema, ReadMultipleFilesArgsSchema, WriteFileArgsSchema, CreateDirectoryArgsSchema, ListDirectoryArgsSchema, MoveFileArgsSchema, GetFileInfoArgsSchema, GetConfigArgsSchema, SetConfigValueArgsSchema, ListProcessesArgsSchema, EditBlockArgsSchema, GetUsageStatsArgsSchema, GiveFeedbackArgsSchema, StartSearchArgsSchema, GetMoreSearchResultsArgsSchema, StopSearchArgsSchema, ListSearchesArgsSchema, GetPromptsArgsSchema, GetRecentToolCallsArgsSchema, } from './tools/schemas.js';
+import { StartProcessArgsSchema, ReadProcessOutputArgsSchema, InteractWithProcessArgsSchema, ForceTerminateArgsSchema, ListSessionsArgsSchema, KillProcessArgsSchema, ReadFileArgsSchema, ReadMultipleFilesArgsSchema, WriteFileArgsSchema, CreateDirectoryArgsSchema, ListDirectoryArgsSchema, MoveFileArgsSchema, GetFileInfoArgsSchema, GetConfigArgsSchema, SetConfigValueArgsSchema, ListProcessesArgsSchema, EditBlockArgsSchema, GetUsageStatsArgsSchema, GiveFeedbackArgsSchema, StartSearchArgsSchema, GetMoreSearchResultsArgsSchema, StopSearchArgsSchema, ListSearchesArgsSchema, GetPromptsArgsSchema, GetRecentToolCallsArgsSchema, WritePdfArgsSchema, } from './tools/schemas.js';
 import { getConfig, setConfigValue } from './tools/config.js';
 import { getUsageStats } from './tools/usage.js';
 import { giveFeedbackToDesktopCommander } from './tools/feedback.js';
@@ -173,7 +173,8 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             {
                 name: "read_file",
                 description: `
-                        Read the contents of a file from the file system or a URL with optional offset and length parameters.
+                        Read contents from files and URLs.
+                        Read PDF files and extract content as markdown and images.
                         
                         Prefer this over 'execute_command' with cat/type for viewing files.
                         
@@ -200,9 +201,17 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         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.
-                        
+                        FORMAT HANDLING (by extension):
+                        - Text: Uses offset/length for line-based pagination
+                        - Excel (.xlsx, .xls, .xlsm): Returns JSON 2D array
+                          * sheet: "Sheet1" (name) or "0" (index as string, 0-based)
+                          * range: ALWAYS use FROM:TO format (e.g., "A1:D100", "C1:C1", "B2:B50")
+                          * offset/length work as row pagination (optional fallback)
+                        - Images (PNG, JPEG, GIF, WebP): Base64 encoded viewable content
+                        - PDF: Extracts text content as markdown with page structure
+                          * offset/length work as page pagination (0-based)
+                          * Includes embedded images when available
+
                         ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
                 inputSchema: zodToJsonSchema(ReadFileArgsSchema),
@@ -235,7 +244,9 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             {
                 name: "write_file",
                 description: `
-                        Write or append to file contents. 
+                        Write or append to file contents.
+
+                        IMPORTANT: DO NOT use this tool to create PDF files. Use 'write_pdf' for all PDF creation tasks.
 
                         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.
@@ -251,16 +262,21 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         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
-                        
+
+                        FORMAT HANDLING (by extension):
+                        - Text files: String content
+                        - Excel (.xlsx, .xls, .xlsm): JSON 2D array or {"SheetName": [[...]]}
+                          Example: '[["Name","Age"],["Alice",30]]'
+
                         Files over 50 lines will generate performance notes but are still written successfully.
                         Only works within allowed directories.
-                        
+
                         ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
                 inputSchema: zodToJsonSchema(WriteFileArgsSchema),
@@ -271,6 +287,68 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     openWorldHint: false,
                 },
             },
+            {
+                name: "write_pdf",
+                description: `
+                        Create a new PDF file or modify an existing one.
+
+                        THIS IS THE ONLY TOOL FOR CREATING AND MODIFYING PDF FILES.
+
+                        RULES ABOUT FILENAMES:
+                        - When creating a new PDF, 'outputPath' MUST be provided and MUST use a new unique filename (e.g., "result_01.pdf", "analysis_2025_01.pdf", etc.).
+
+                        MODES:
+                        1. CREATE NEW PDF:
+                           - Pass a markdown string as 'content'.
+                           write_pdf(path="doc.pdf", content="# Title\\n\\nBody text...")
+
+                        2. MODIFY EXISTING PDF:
+                           - Pass array of operations as 'content'.
+                           - NEVER overwrite the original file.
+                           - ALWAYS provide a new filename in 'outputPath'.
+                           - After modifying, show original file path and new file path to user.
+
+                           write_pdf(path="doc.pdf", content=[
+                               { type: "delete", pageIndexes: [0, 2] },
+                               { type: "insert", pageIndex: 1, markdown: "# New Page" }
+                           ])
+
+                        OPERATIONS:
+                        - delete: Remove pages by 0-based index.
+                          { type: "delete", pageIndexes: [0, 1, 5] }
+
+                        - insert: Add pages at a specific 0-based index.
+                          { type: "insert", pageIndex: 0, markdown: "..." }
+                          { type: "insert", pageIndex: 5, sourcePdfPath: "/path/to/source.pdf" }
+
+                        PAGE BREAKS:
+                        To force a page break, use this HTML element:
+                        <div style="page-break-before: always;"></div>
+                        
+                        Example:
+                        "# Page 1\\n\\n<div style=\\"page-break-before: always;\\"></div>\\n\\n# Page 2"
+
+                        ADVANCED STYLING:
+                        HTML/CSS and inline SVG are supported for:
+                        - Text styling: colors, sizes, alignment, highlights
+                        - Boxes: borders, backgrounds, padding, rounded corners
+                        - SVG graphics: charts, diagrams, icons, shapes
+                        - Images: <img src="/absolute/path/image.jpg" width="300" /> or ![alt](/path/image.jpg)
+
+                        Supports standard markdown features including headers, lists, code blocks, tables, and basic formatting.
+
+                        Only works within allowed directories.
+
+                        ${PATH_GUIDANCE}
+                        ${CMD_PREFIX_DESCRIPTION}`,
+                inputSchema: zodToJsonSchema(WritePdfArgsSchema),
+                annotations: {
+                    title: "Write/Modify PDF",
+                    readOnlyHint: false,
+                    destructiveHint: true,
+                    openWorldHint: false,
+                },
+            },
             {
                 name: "create_directory",
                 description: `
@@ -489,13 +567,14 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         Retrieve detailed metadata about a file or directory including:
                         - size
                         - creation time
-                        - last modified time 
+                        - last modified time
                         - permissions
                         - type
                         - lineCount (for text files)
                         - lastLine (zero-indexed number of last line, for text files)
                         - appendPosition (line number for appending, for text files)
-                        
+                        - sheets (for Excel files - array of {name, rowCount, colCount})
+
                         Only works within allowed directories.
                         
                         ${PATH_GUIDANCE}
@@ -507,45 +586,54 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                 },
             },
             // Note: list_allowed_directories removed - use get_config to check allowedDirectories
-            // Text editing tools
+            // Editing tools
             {
                 name: "edit_block",
                 description: `
-                        Apply surgical text replacements to files.
-                        
+                        Apply surgical edits to files.
+
                         BEST PRACTICE: Make multiple small, focused edits rather than one large edit.
-                        Each edit_block call should change only what needs to be changed - include just enough 
+                        Each edit_block call should change only what needs to be changed - include just enough
                         context to uniquely identify the text being modified.
-                        
+
+                        FORMAT HANDLING (by extension):
+
+                        EXCEL FILES (.xlsx, .xls, .xlsm) - Range Update mode:
+                        Takes:
+                        - file_path: Path to the Excel file
+                        - range: ALWAYS use FROM:TO format - "SheetName!A1:C10" or "SheetName!C1:C1"
+                        - content: 2D array, e.g., [["H1","H2"],["R1","R2"]]
+
+                        TEXT FILES - Find/Replace mode:
                         Takes:
                         - file_path: Path to the file to edit
                         - old_string: Text to replace
                         - new_string: Replacement text
-                        - expected_replacements: Optional parameter for number of replacements
-                        
+                        - expected_replacements: Optional number of replacements (default: 1)
+
                         By default, replaces only ONE occurrence of the search text.
-                        To replace multiple occurrences, provide the expected_replacements parameter with
+                        To replace multiple occurrences, provide expected_replacements 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.
-                        
+
                         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),
                 annotations: {
-                    title: "Edit Text Block",
+                    title: "Edit Block",
                     readOnlyHint: false,
                     destructiveHint: true,
                     openWorldHint: false,
@@ -574,7 +662,8 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         
                         COMMON FILE ANALYSIS PATTERNS:
                         • start_process("python3 -i") → Python REPL for data analysis (RECOMMENDED)
-                        • start_process("node -i") → Node.js for JSON processing  
+                        • start_process("node -i") → Node.js REPL for JSON processing
+                        • start_process("node:local") → Node.js on MCP server (stateless, ES imports, all code in one call)
                         • start_process("cut -d',' -f1 file.csv | sort | uniq -c") → Quick CSV analysis
                         • start_process("wc -l /path/file.csv") → Line counting
                         • start_process("head -10 /path/file.csv") → File preview
@@ -583,12 +672,15 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         For PDF, Excel, Word, archives, databases, and other binary formats, use process tools with appropriate libraries or command-line utilities.
                         
                         INTERACTIVE PROCESSES FOR DATA ANALYSIS:
-                        1. start_process("python3 -i") - Start Python REPL for data work
-                        2. start_process("node -i") - Start Node.js REPL for JSON/JS
-                        3. start_process("bash") - Start interactive bash shell
+                        For code/calculations, use in this priority order:
+                        1. start_process("python3 -i") - Python REPL (preferred)
+                        2. start_process("node -i") - Node.js REPL (when Python unavailable)
+                        3. start_process("node:local") - Node.js fallback (when node -i fails)
                         4. Use interact_with_process() to send commands
                         5. Use read_process_output() to get responses
-                        
+                        When Python is unavailable, prefer Node.js over shell for calculations.
+                        Node.js: Always use ES import syntax (import x from 'y'), not require().
+
                         SMART DETECTION:
                         - Detects REPL prompts (>>>, >, $, etc.)
                         - Identifies when process is waiting for input
@@ -624,35 +716,37 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             {
                 name: "read_process_output",
                 description: `
-                        Read output from a running process with intelligent completion detection.
+                        Read output from a running process with file-like pagination support.
                         
-                        Automatically detects when process is ready for more input instead of timing out.
+                        Supports partial output reading with offset and length parameters (like read_file):
+                        - 'offset' (start line, default: 0)
+                          * offset=0: Read NEW output since last read (default, like old behavior)
+                          * Positive: Read from absolute line position
+                          * Negative: Read last N lines from end (tail behavior)
+                        - 'length' (max lines to read, default: configurable via 'fileReadLineLimit' setting)
                         
-                        SMART FEATURES:
-                        - Early exit when REPL shows prompt (>>>, >, etc.)
-                        - Detects process completion vs still running
-                        - Prevents hanging on interactive prompts
-                        - Clear status messages about process state
+                        Examples:
+                        - offset: 0, length: 100     → First 100 NEW lines since last read
+                        - offset: 0                  → All new lines (respects config limit)
+                        - offset: 500, length: 50    → Lines 500-549 (absolute position)
+                        - offset: -20                → Last 20 lines (tail)
+                        - offset: -50, length: 10    → Start 50 from end, read 10 lines
+                        
+                        OUTPUT PROTECTION:
+                        - Uses same fileReadLineLimit as read_file (default: 1000 lines)
+                        - Returns status like: [Reading 100 lines from line 0 (total: 5000 lines, 4900 remaining)]
+                        - Prevents context overflow from verbose processes
                         
-                        REPL USAGE:
-                        - Stops immediately when REPL prompt detected
-                        - Shows clear status: waiting for input vs finished
-                        - Shorter timeouts needed due to smart detection
-                        - Works with Python, Node.js, R, Julia, etc.
+                        SMART FEATURES:
+                        - For offset=0, waits up to timeout_ms for new output to arrive
+                        - Detects REPL prompts and process completion
+                        - Shows process state (waiting for input, finished, etc.)
                         
                         DETECTION STATES:
                         Process waiting for input (ready for interact_with_process)
                         Process finished execution
                         Timeout reached (may still be running)
 
-                        PERFORMANCE DEBUGGING (verbose_timing parameter):
-                        Set verbose_timing: true to get detailed timing information including:
-                        - Exit reason (early_exit_quick_pattern, early_exit_periodic_check, process_finished, timeout)
-                        - Total duration and time to first output
-                        - Complete timeline of all output events with timestamps
-                        - Which detection mechanism triggered early exit
-                        Use this to identify when timeouts could be reduced or detection patterns improved.
-
                         ${CMD_PREFIX_DESCRIPTION}`,
                 inputSchema: zodToJsonSchema(ReadProcessOutputArgsSchema),
                 annotations: {
@@ -692,7 +786,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         
                         SUPPORTED REPLs:
                         - Python: python3 -i (RECOMMENDED for data analysis)
-                        - Node.js: node -i  
+                        - Node.js: node -i
                         - R: R
                         - Julia: julia
                         - Shell: bash, zsh
@@ -781,9 +875,9 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                 name: "kill_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),
                 annotations: {
@@ -881,27 +975,14 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         
                         USAGE:
                         When user says "1", "2", "3", "4", or "5" from onboarding:
-                        - "1" → get_prompts(action='get_prompt', promptId='onb2_01', anonymous_user_use_case='...')
-                        - "2" → get_prompts(action='get_prompt', promptId='onb2_02', anonymous_user_use_case='...')
-                        - "3" → get_prompts(action='get_prompt', promptId='onb2_03', anonymous_user_use_case='...')
-                        - "4" → get_prompts(action='get_prompt', promptId='onb2_04', anonymous_user_use_case='...')
-                        - "5" → get_prompts(action='get_prompt', promptId='onb2_05', anonymous_user_use_case='...')
-                        
-                        ANONYMOUS USE CASE (REQUIRED):
-                        Infer what GOAL or PROBLEM the user is trying to solve from conversation history.
-                        Focus on the job-to-be-done, not just what they were doing.
-                        
-                        GOOD (problem/goal focused):
-                        "automating backup workflow", "converting PDFs to CSV", "debugging test failures",
-                        "organizing project files", "monitoring server logs", "extracting data from documents"
-                        
-                        BAD (too vague or contains PII):
-                        "using Desktop Commander", "working on John's project", "fixing acme-corp bug"
-                        
-                        If unclear from context, use: "exploring tool capabilities"
+                        - "1" → get_prompts(action='get_prompt', promptId='onb2_01')
+                        - "2" → get_prompts(action='get_prompt', promptId='onb2_02')
+                        - "3" → get_prompts(action='get_prompt', promptId='onb2_03')
+                        - "4" → get_prompts(action='get_prompt', promptId='onb2_04')
+                        - "5" → get_prompts(action='get_prompt', promptId='onb2_05')
                         
                         The prompt content will be injected and execution begins immediately.
-                        
+
                         ${CMD_PREFIX_DESCRIPTION}`,
                 inputSchema: zodToJsonSchema(GetPromptsArgsSchema),
             }
@@ -940,6 +1021,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             }
         }
         capture_call_tool('server_call_tool', telemetryData);
+        // Log every tool request name
+        // logger.info(`Tool request: ${name}`, { toolName: name, timestamp: new Date().toISOString() });
         // Track tool call
         trackToolCall(name, args);
         // Using a more structured approach with dedicated handlers
@@ -1001,7 +1084,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                                         category: prompt.categories[0] || 'uncategorized',
                                         author: prompt.author,
                                         verified: prompt.verified,
-                                        anonymous_use_case: args.anonymous_user_use_case || null
+                                        // Temporarily disabled for privacy review - Dec 2025
+                                        // anonymous_use_case: (args as any).anonymous_user_use_case || null
                                     });
                                 }
                             }
@@ -1083,6 +1167,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "write_file":
                 result = await handlers.handleWriteFile(args);
                 break;
+            case "write_pdf":
+                result = await handlers.handleWritePdf(args);
+                break;
             case "create_directory":
                 result = await handlers.handleCreateDirectory(args);
                 break;