@wonderwhy-er/desktop-commander 0.2.10 → 0.2.11

package/dist/search-manager.js

@@ -0,0 +1,467 @@
+import { spawn } from 'child_process';
+import { rgPath } from '@vscode/ripgrep';
+import path from 'path';
+import { validatePath } from './tools/filesystem.js';
+import { capture } from './utils/capture.js';
+/**
+ * Search Session Manager - handles ripgrep processes like terminal sessions
+ * Supports both file search and content search with progressive results
+ */ export class SearchManager {
+    constructor() {
+        this.sessions = new Map();
+        this.sessionCounter = 0;
+    }
+    /**
+     * Start a new search session (like start_process)
+     * Returns immediately with initial state and results
+     */
+    async startSearch(options) {
+        const sessionId = `search_${++this.sessionCounter}_${Date.now()}`;
+        // Validate path first
+        const validPath = await validatePath(options.rootPath);
+        // Build ripgrep arguments
+        const args = this.buildRipgrepArgs({ ...options, rootPath: validPath });
+        // Start ripgrep process
+        const rgProcess = spawn(rgPath, args);
+        if (!rgProcess.pid) {
+            throw new Error('Failed to start ripgrep process');
+        }
+        // Create session
+        const session = {
+            id: sessionId,
+            process: rgProcess,
+            results: [],
+            isComplete: false,
+            isError: false,
+            startTime: Date.now(),
+            lastReadTime: Date.now(),
+            options,
+            buffer: '',
+            totalMatches: 0,
+            totalContextLines: 0
+        };
+        this.sessions.set(sessionId, session);
+        // Set up process event handlers
+        this.setupProcessHandlers(session);
+        // Start cleanup interval now that we have a session
+        startCleanupIfNeeded();
+        // Set up timeout if specified and auto-terminate
+        // For exact filename searches, use a shorter default timeout
+        const timeoutMs = options.timeout ?? (this.isExactFilename(options.pattern) ? 1500 : undefined);
+        let killTimer = null;
+        if (timeoutMs) {
+            killTimer = setTimeout(() => {
+                if (!session.isComplete && !session.process.killed) {
+                    session.process.kill('SIGTERM');
+                }
+            }, timeoutMs);
+        }
+        // Clear timer on process completion
+        session.process.once('close', () => {
+            if (killTimer) {
+                clearTimeout(killTimer);
+                killTimer = null;
+            }
+        });
+        session.process.once('error', () => {
+            if (killTimer) {
+                clearTimeout(killTimer);
+                killTimer = null;
+            }
+        });
+        capture('search_session_started', {
+            sessionId,
+            searchType: options.searchType,
+            hasTimeout: !!timeoutMs,
+            timeoutMs,
+            requestedPath: options.rootPath,
+            validatedPath: validPath
+        });
+        // Wait for first chunk of data or early completion instead of fixed delay
+        const firstChunk = new Promise(resolve => {
+            const onData = () => {
+                session.process.stdout?.off('data', onData);
+                resolve();
+            };
+            session.process.stdout?.once('data', onData);
+            setTimeout(resolve, 40); // cap at 40ms instead of 50-100ms
+        });
+        await firstChunk;
+        return {
+            sessionId,
+            isComplete: session.isComplete,
+            isError: session.isError,
+            results: [...session.results],
+            totalResults: session.totalMatches,
+            runtime: Date.now() - session.startTime
+        };
+    }
+    /**
+     * Read search results with offset-based pagination (like read_file)
+     * Supports both range reading and tail behavior
+     */
+    readSearchResults(sessionId, offset = 0, length = 100) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Search session ${sessionId} not found`);
+        }
+        // Get all results (excluding internal markers)
+        const allResults = session.results.filter(r => r.file !== '__LAST_READ_MARKER__');
+        // Handle negative offsets (tail behavior) - like file reading
+        if (offset < 0) {
+            const tailCount = Math.abs(offset);
+            const tailResults = allResults.slice(-tailCount);
+            return {
+                results: tailResults,
+                returnedCount: tailResults.length,
+                totalResults: session.totalMatches + session.totalContextLines,
+                totalMatches: session.totalMatches, // Actual matches only
+                isComplete: session.isComplete,
+                isError: session.isError && !!session.error?.trim(), // Only error if we have actual errors
+                error: session.error?.trim() || undefined,
+                hasMoreResults: false, // Tail always returns what's available
+                runtime: Date.now() - session.startTime
+            };
+        }
+        // Handle positive offsets (range behavior) - like file reading
+        const slicedResults = allResults.slice(offset, offset + length);
+        const hasMoreResults = offset + length < allResults.length || !session.isComplete;
+        session.lastReadTime = Date.now();
+        return {
+            results: slicedResults,
+            returnedCount: slicedResults.length,
+            totalResults: session.totalMatches + session.totalContextLines,
+            totalMatches: session.totalMatches, // Actual matches only
+            isComplete: session.isComplete,
+            isError: session.isError && !!session.error?.trim(), // Only error if we have actual errors
+            error: session.error?.trim() || undefined,
+            hasMoreResults,
+            runtime: Date.now() - session.startTime
+        };
+    }
+    /**
+     * Terminate a search session (like force_terminate)
+     */
+    terminateSearch(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return false;
+        }
+        if (!session.process.killed) {
+            session.process.kill('SIGTERM');
+            capture('search_session_terminated', { sessionId });
+        }
+        // Don't delete session immediately - let user read final results
+        // It will be cleaned up by cleanup process
+        return true;
+    }
+    /**
+     * Get list of active search sessions (like list_sessions)
+     */
+    listSearchSessions() {
+        return Array.from(this.sessions.values()).map(session => ({
+            id: session.id,
+            searchType: session.options.searchType,
+            pattern: session.options.pattern,
+            isComplete: session.isComplete,
+            isError: session.isError,
+            runtime: Date.now() - session.startTime,
+            totalResults: session.totalMatches + session.totalContextLines
+        }));
+    }
+    /**
+     * Clean up completed sessions older than specified time
+     * Called automatically by cleanup interval
+     */
+    cleanupSessions(maxAge = 5 * 60 * 1000) {
+        const cutoffTime = Date.now() - maxAge;
+        for (const [sessionId, session] of this.sessions) {
+            if (session.isComplete && session.lastReadTime < cutoffTime) {
+                this.sessions.delete(sessionId);
+                capture('search_session_cleaned_up', { sessionId });
+            }
+        }
+    }
+    /**
+     * Get total number of active sessions (excluding completed ones)
+     */
+    getActiveSessionCount() {
+        return Array.from(this.sessions.values()).filter(session => !session.isComplete).length;
+    }
+    /**
+     * Detect if pattern looks like an exact filename
+     * (has file extension and no glob wildcards)
+     */
+    isExactFilename(pattern) {
+        return /\.[a-zA-Z0-9]+$/.test(pattern) &&
+            !this.isGlobPattern(pattern);
+    }
+    /**
+     * Detect if pattern contains glob wildcards
+     */
+    isGlobPattern(pattern) {
+        return pattern.includes('*') ||
+            pattern.includes('?') ||
+            pattern.includes('[') ||
+            pattern.includes('{') ||
+            pattern.includes(']') ||
+            pattern.includes('}');
+    }
+    buildRipgrepArgs(options) {
+        const args = [];
+        if (options.searchType === 'content') {
+            // Content search mode
+            args.push('--json', '--line-number');
+            if (options.contextLines && options.contextLines > 0) {
+                args.push('-C', options.contextLines.toString());
+            }
+        }
+        else {
+            // File search mode
+            args.push('--files');
+        }
+        // Case-insensitive: content searches use -i flag, file searches use --iglob
+        if (options.searchType === 'content' && options.ignoreCase !== false) {
+            args.push('-i');
+        }
+        if (options.includeHidden) {
+            args.push('--hidden');
+        }
+        if (options.maxResults && options.maxResults > 0) {
+            args.push('-m', options.maxResults.toString());
+        }
+        // File pattern filtering (for file type restrictions like *.js, *.d.ts)
+        if (options.filePattern) {
+            const patterns = options.filePattern
+                .split('|')
+                .map(p => p.trim())
+                .filter(Boolean);
+            for (const p of patterns) {
+                if (options.searchType === 'content') {
+                    args.push('-g', p);
+                }
+                else {
+                    // For file search: use --iglob for case-insensitive or --glob for case-sensitive
+                    if (options.ignoreCase !== false) {
+                        args.push('--iglob', p);
+                    }
+                    else {
+                        args.push('--glob', p);
+                    }
+                }
+            }
+        }
+        // Handle the main search pattern
+        if (options.searchType === 'files') {
+            // For file search: determine how to treat the pattern
+            const globFlag = options.ignoreCase !== false ? '--iglob' : '--glob';
+            if (this.isExactFilename(options.pattern)) {
+                // Exact filename: use appropriate glob flag with the exact pattern
+                args.push(globFlag, options.pattern);
+            }
+            else if (this.isGlobPattern(options.pattern)) {
+                // Already a glob pattern: use appropriate glob flag as-is
+                args.push(globFlag, options.pattern);
+            }
+            else {
+                // Substring/fuzzy search: wrap with wildcards
+                args.push(globFlag, `*${options.pattern}*`);
+            }
+            // Add the root path for file mode
+            args.push(options.rootPath);
+        }
+        else {
+            // Content search: terminate options before the pattern to prevent 
+            // patterns starting with '-' being interpreted as flags
+            args.push('--', options.pattern, options.rootPath);
+        }
+        return args;
+    }
+    setupProcessHandlers(session) {
+        const { process } = session;
+        process.stdout?.on('data', (data) => {
+            session.buffer += data.toString();
+            this.processBufferedOutput(session);
+        });
+        process.stderr?.on('data', (data) => {
+            const errorText = data.toString();
+            // Filter meaningful errors
+            const filteredErrors = errorText
+                .split('\n')
+                .filter(line => {
+                const trimmed = line.trim();
+                // Skip empty lines and lines with just symbols/numbers/colons
+                if (!trimmed || trimmed.match(/^[\)\(\s\d:]*$/))
+                    return false;
+                // Skip all ripgrep system errors that start with "rg:"
+                if (trimmed.startsWith('rg:'))
+                    return false;
+                return true;
+            });
+            // Only add to session.error if there are actual meaningful errors after filtering
+            if (filteredErrors.length > 0) {
+                const meaningfulErrors = filteredErrors.join('\n').trim();
+                if (meaningfulErrors) {
+                    session.error = (session.error || '') + meaningfulErrors + '\n';
+                    capture('search_session_error', {
+                        sessionId: session.id,
+                        error: meaningfulErrors.substring(0, 200)
+                    });
+                }
+            }
+        });
+        process.on('close', (code) => {
+            // Process any remaining buffer content
+            if (session.buffer.trim()) {
+                this.processBufferedOutput(session, true);
+            }
+            session.isComplete = true;
+            // Only treat as error if:
+            // 1. Unexpected exit code (not 0, 1, or 2) AND
+            // 2. We have meaningful errors after filtering AND
+            // 3. We found no results at all
+            if (code !== 0 && code !== 1 && code !== 2) {
+                // Codes 0=success, 1=no matches, 2=some files couldn't be searched
+                if (session.error?.trim() && session.totalMatches === 0) {
+                    session.isError = true;
+                    session.error = session.error || `ripgrep exited with code ${code}`;
+                }
+            }
+            // If we have results, don't mark as error even if there were permission issues
+            if (session.totalMatches > 0) {
+                session.isError = false;
+            }
+            capture('search_session_completed', {
+                sessionId: session.id,
+                exitCode: code,
+                totalResults: session.totalMatches + session.totalContextLines,
+                totalMatches: session.totalMatches,
+                runtime: Date.now() - session.startTime
+            });
+            // Rely on cleanupSessions(maxAge) only; no per-session timer
+        });
+        process.on('error', (error) => {
+            session.isComplete = true;
+            session.isError = true;
+            session.error = `Process error: ${error.message}`;
+            capture('search_session_process_error', {
+                sessionId: session.id,
+                error: error.message
+            });
+            // Rely on cleanupSessions(maxAge) only; no per-session timer
+        });
+    }
+    processBufferedOutput(session, isFinal = false) {
+        const lines = session.buffer.split('\n');
+        // Keep the last incomplete line in the buffer unless this is final processing
+        if (!isFinal) {
+            session.buffer = lines.pop() || '';
+        }
+        else {
+            session.buffer = '';
+        }
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            const result = this.parseLine(line, session.options.searchType);
+            if (result) {
+                session.results.push(result);
+                // Separate counting of matches vs context lines
+                if (result.type === 'content' && line.includes('"type":"context"')) {
+                    session.totalContextLines++;
+                }
+                else {
+                    session.totalMatches++;
+                }
+                // Early termination for exact filename matches (if enabled)
+                if (session.options.earlyTermination !== false && // Default to true
+                    session.options.searchType === 'files' &&
+                    this.isExactFilename(session.options.pattern)) {
+                    const pat = path.normalize(session.options.pattern);
+                    const filePath = path.normalize(result.file);
+                    const ignoreCase = session.options.ignoreCase !== false;
+                    const ends = ignoreCase
+                        ? filePath.toLowerCase().endsWith(pat.toLowerCase())
+                        : filePath.endsWith(pat);
+                    if (ends) {
+                        // Found exact match, terminate search early
+                        setTimeout(() => {
+                            if (!session.process.killed) {
+                                session.process.kill('SIGTERM');
+                            }
+                        }, 100); // Small delay to allow any remaining results
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    parseLine(line, searchType) {
+        if (searchType === 'content') {
+            // Parse JSON output from content search
+            try {
+                const parsed = JSON.parse(line);
+                if (parsed.type === 'match') {
+                    // Handle multiple submatches per line - return first submatch
+                    const submatch = parsed.data?.submatches?.[0];
+                    return {
+                        file: parsed.data.path.text,
+                        line: parsed.data.line_number,
+                        match: submatch?.match?.text || parsed.data.lines.text,
+                        type: 'content'
+                    };
+                }
+                if (parsed.type === 'context') {
+                    return {
+                        file: parsed.data.path.text,
+                        line: parsed.data.line_number,
+                        match: parsed.data.lines.text.trim(),
+                        type: 'content'
+                    };
+                }
+                // Handle summary to reconcile totals
+                if (parsed.type === 'summary') {
+                    // Optional: could reconcile totalMatches with parsed.data.stats?.matchedLines
+                    return null;
+                }
+                return null;
+            }
+            catch (error) {
+                // Skip invalid JSON lines
+                return null;
+            }
+        }
+        else {
+            // File search - each line is a file path
+            return {
+                file: line.trim(),
+                type: 'file'
+            };
+        }
+    }
+}
+// Global search manager instance
+export const searchManager = new SearchManager();
+// Cleanup management - run on fixed schedule
+let cleanupInterval = null;
+/**
+ * Start cleanup interval - now runs on fixed schedule
+ */
+function startCleanupIfNeeded() {
+    if (!cleanupInterval) {
+        cleanupInterval = setInterval(() => {
+            searchManager.cleanupSessions();
+        }, 5 * 60 * 1000);
+        // Also check immediately after a short delay (let search process finish)
+        setTimeout(() => {
+            searchManager.cleanupSessions();
+        }, 1000);
+    }
+}
+// Export cleanup function for graceful shutdown
+export function stopSearchManagerCleanup() {
+    if (cleanupInterval) {
+        clearInterval(cleanupInterval);
+        cleanupInterval = null;
+    }
+}

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, SearchFilesArgsSchema, GetFileInfoArgsSchema, SearchCodeArgsSchema, GetConfigArgsSchema, SetConfigValueArgsSchema, ListProcessesArgsSchema, EditBlockArgsSchema, GetUsageStatsArgsSchema, GiveFeedbackArgsSchema, } 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, } from './tools/schemas.js';
 import { getConfig, setConfigValue } from './tools/config.js';
 import { getUsageStats } from './tools/usage.js';
 import { giveFeedbackToDesktopCommander } from './tools/feedback.js';
@@ -17,7 +17,8 @@ import { usageTracker } from './utils/usageTracker.js';
 import { processDockerPrompt } from './utils/dockerPrompt.js';
 import { VERSION } from './version.js';
 import { capture, capture_call_tool } from "./utils/capture.js";
-console.error("Loading server.ts");
+import { logToStderr } from './utils/logger.js';
+logToStderr('info', 'Loading server.ts');
 export const server = new Server({
     name: "desktop-commander",
     version: VERSION,
@@ -55,7 +56,8 @@ server.setRequestHandler(InitializeRequestSchema, async (request) => {
                 name: clientInfo.name || 'unknown',
                 version: clientInfo.version || 'unknown'
             };
-            console.log(`Client connected: ${currentClient.name} v${currentClient.version}`);
+            // Send JSON-RPC notification about client connection
+            logToStderr('info', `Client connected: ${currentClient.name} v${currentClient.version}`);
         }
         // Return standard initialization response
         return {
@@ -73,16 +75,16 @@ server.setRequestHandler(InitializeRequestSchema, async (request) => {
         };
     }
     catch (error) {
-        console.error("Error in initialization handler:", error);
+        logToStderr('error', `Error in initialization handler: ${error}`);
         throw error;
     }
 });
 // Export current client info for access by other modules
 export { currentClient };
-console.error("Setting up request handlers...");
+logToStderr('info', 'Setting up request handlers...');
 server.setRequestHandler(ListToolsRequestSchema, async () => {
     try {
-        console.error("Generating tools list...");
+        logToStderr('debug', 'Generating tools list...');
         return {
             tools: [
                 // Configuration tools
@@ -250,35 +252,92 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     inputSchema: zodToJsonSchema(MoveFileArgsSchema),
                 },
                 {
-                    name: "search_files",
+                    name: "start_search",
                     description: `
-                        Finds files by name using a case-insensitive substring matching.
+                        Start a streaming search that can return results progressively.
+                        
+                        SEARCH TYPES:
+                        - searchType="files": Find files by name (pattern matches file names)
+                        - searchType="content": Search inside files for text patterns
+                        
+                        IMPORTANT PARAMETERS:
+                        - pattern: What to search for (file names OR content text)
+                        - filePattern: Optional filter to limit search to specific file types (e.g., "*.js", "package.json")
+                        - ignoreCase: Case-insensitive search (default: true). Works for both file names and content.
+                        - earlyTermination: Stop search early when exact filename match is found (optional: defaults to true for file searches, false for content searches)
+                        
+                        EXAMPLES:
+                        - Find package.json files: searchType="files", pattern="package.json", filePattern="package.json"
+                        - Find all JS files: searchType="files", pattern="*.js" (or use filePattern="*.js")
+                        - Search for "TODO" in code: searchType="content", pattern="TODO", filePattern="*.js|*.ts"
+                        - Case-sensitive file search: searchType="files", pattern="README", ignoreCase=false
+                        - Case-insensitive file search: searchType="files", pattern="readme", ignoreCase=true
+                        - Find exact file, stop after first match: searchType="files", pattern="config.json", earlyTermination=true
+                        - Find all matching files: searchType="files", pattern="test.js", earlyTermination=false
+                        
+                        Unlike regular search tools, this starts a background search process and returns
+                        immediately with a session ID. Use get_more_search_results to get results as they
+                        come in, and stop_search to stop the search early if needed.
+                        
+                        Perfect for large directories where you want to see results immediately and
+                        have the option to cancel if the search takes too long or you find what you need.
                         
-                        Use this instead of 'execute_command' with find/dir/ls for locating files.
-                        Searches through all subdirectories from the starting path.
+                        ${PATH_GUIDANCE}
+                        ${CMD_PREFIX_DESCRIPTION}`,
+                    inputSchema: zodToJsonSchema(StartSearchArgsSchema),
+                },
+                {
+                    name: "get_more_search_results",
+                    description: `
+                        Get more results from an active search with offset-based pagination.
                         
-                        Has a default timeout of 30 seconds which can be customized using the timeoutMs parameter.
-                        Only searches within allowed directories.
+                        Supports partial result reading with:
+                        - 'offset' (start result index, default: 0)
+                          * Positive: Start from result N (0-based indexing)
+                          * Negative: Read last N results from end (tail behavior)
+                        - 'length' (max results to read, default: 100)
+                          * Used with positive offsets for range reading
+                          * Ignored when offset is negative (reads all requested tail results)
+                        
+                        Examples:
+                        - offset: 0, length: 100     → First 100 results
+                        - offset: 200, length: 50    → Results 200-249
+                        - offset: -20                → Last 20 results
+                        - offset: -5, length: 10     → Last 5 results (length ignored)
+                        
+                        Returns only results in the specified range, along with search status.
+                        Works like read_process_output - call this repeatedly to get progressive
+                        results from a search started with start_search.
                         
-                        ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(SearchFilesArgsSchema),
+                    inputSchema: zodToJsonSchema(GetMoreSearchResultsArgsSchema),
                 },
                 {
-                    name: "search_code",
+                    name: "stop_search",
                     description: `
-                        Search for text/code patterns within file contents using ripgrep.
+                        Stop an active search.
                         
-                        Use this instead of 'execute_command' with grep/find for searching code content.
-                        Fast and powerful search similar to VS Code search functionality.
+                        Stops the background search process gracefully. Use this when you've found
+                        what you need or if a search is taking too long. Similar to force_terminate
+                        for terminal processes.
                         
-                        Supports regular expressions, file pattern filtering, and context lines.
-                        Has a default timeout of 30 seconds which can be customized.
-                        Only searches within allowed directories.
+                        The search will still be available for reading final results until it's
+                        automatically cleaned up after 5 minutes.
                         
-                        ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(SearchCodeArgsSchema),
+                    inputSchema: zodToJsonSchema(StopSearchArgsSchema),
+                },
+                {
+                    name: "list_searches",
+                    description: `
+                        List all active searches.
+                        
+                        Shows search IDs, search types, patterns, status, and runtime.
+                        Similar to list_sessions for terminal processes. Useful for managing
+                        multiple concurrent searches.
+                        
+                        ${CMD_PREFIX_DESCRIPTION}`,
+                    inputSchema: zodToJsonSchema(ListSearchesArgsSchema),
                 },
                 {
                     name: "get_file_info",
@@ -570,7 +629,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
         };
     }
     catch (error) {
-        console.error("Error in list_tools request handler:", error);
+        logToStderr('error', `Error in list_tools request handler: ${error}`);
         throw error;
     }
 });
@@ -578,9 +637,12 @@ import * as handlers from './handlers/index.js';
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     try {
-        capture_call_tool('server_call_tool', {
-            name
-        });
+        // Prepare telemetry data - add config key for set_config_value
+        const telemetryData = { name };
+        if (name === 'set_config_value' && args && typeof args === 'object' && 'key' in args) {
+            telemetryData.set_config_value_key_name = args.key;
+        }
+        capture_call_tool('server_call_tool', telemetryData);
         // Track tool call
         trackToolCall(name, args);
         // Using a more structured approach with dedicated handlers
@@ -678,11 +740,17 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "move_file":
                 result = await handlers.handleMoveFile(args);
                 break;
-            case "search_files":
-                result = await handlers.handleSearchFiles(args);
+            case "start_search":
+                result = await handlers.handleStartSearch(args);
+                break;
+            case "get_more_search_results":
+                result = await handlers.handleGetMoreSearchResults(args);
+                break;
+            case "stop_search":
+                result = await handlers.handleStopSearch(args);
                 break;
-            case "search_code":
-                result = await handlers.handleSearchCode(args);
+            case "list_searches":
+                result = await handlers.handleListSearches();
                 break;
             case "get_file_info":
                 result = await handlers.handleGetFileInfo(args);