@wonderwhy-er/desktop-commander 0.2.5 → 0.2.7

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

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

package/dist/handlers/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/handlers/index.ts"],"names":[],"mappings":"AAAA,kDAAkD;AAClD,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC"}

package/dist/handlers/process-handlers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"process-handlers.js","sourceRoot":"","sources":["../../src/handlers/process-handlers.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,aAAa,EACb,WAAW,EACd,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACH,qBAAqB,EACxB,MAAM,qBAAqB,CAAC;AAI7B;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB;IACrC,OAAO,aAAa,EAAE,CAAC;AAC3B,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CAAC,IAAa;IACjD,MAAM,MAAM,GAAG,qBAAqB,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACjD,OAAO,WAAW,CAAC,MAAM,CAAC,CAAC;AAC/B,CAAC"}

package/dist/handlers/repl-handlers.d.ts

@@ -1,21 +0,0 @@
-import { ServerResult } from '../types.js';
-/**
- * Handle create_repl_session command
- */
-export declare function handleCreateREPLSession(args: unknown): Promise<ServerResult>;
-/**
- * Handle execute_repl_code command
- */
-export declare function handleExecuteREPLCode(args: unknown): Promise<ServerResult>;
-/**
- * Handle terminate_repl_session command
- */
-export declare function handleTerminateREPLSession(args: unknown): Promise<ServerResult>;
-/**
- * Handle list_repl_sessions command
- */
-export declare function handleListREPLSessions(args?: unknown): Promise<ServerResult>;
-/**
- * Handle get_repl_session_info command
- */
-export declare function handleGetREPLSessionInfo(args: unknown): Promise<ServerResult>;

package/dist/handlers/repl-handlers.js

@@ -1,37 +0,0 @@
-import { createREPLSession, executeREPLCode, terminateREPLSession, listREPLSessions, getREPLSessionInfo } from '../tools/repl.js';
-import { CreateREPLSessionArgsSchema, ExecuteREPLCodeArgsSchema, TerminateREPLSessionArgsSchema, ListREPLSessionsArgsSchema, GetREPLSessionInfoArgsSchema } from '../tools/schemas.js';
-/**
- * Handle create_repl_session command
- */
-export async function handleCreateREPLSession(args) {
-    const parsed = CreateREPLSessionArgsSchema.parse(args);
-    return createREPLSession(parsed);
-}
-/**
- * Handle execute_repl_code command
- */
-export async function handleExecuteREPLCode(args) {
-    const parsed = ExecuteREPLCodeArgsSchema.parse(args);
-    return executeREPLCode(parsed);
-}
-/**
- * Handle terminate_repl_session command
- */
-export async function handleTerminateREPLSession(args) {
-    const parsed = TerminateREPLSessionArgsSchema.parse(args);
-    return terminateREPLSession(parsed);
-}
-/**
- * Handle list_repl_sessions command
- */
-export async function handleListREPLSessions(args = {}) {
-    const parsed = ListREPLSessionsArgsSchema.parse(args);
-    return listREPLSessions(parsed);
-}
-/**
- * Handle get_repl_session_info command
- */
-export async function handleGetREPLSessionInfo(args) {
-    const parsed = GetREPLSessionInfoArgsSchema.parse(args);
-    return getREPLSessionInfo(parsed);
-}

package/dist/handlers/replCommandHandler.d.ts

@@ -1,125 +0,0 @@
-/**
- * Initialize the REPL manager with a terminal manager instance
- * @param terminalManager - The terminal manager instance
- */
-export declare function initializeREPLManager(terminalManager: any): void;
-interface REPLSessionParams {
-    language: string;
-    options?: any;
-}
-interface ExecuteCodeParams {
-    pid: number | string;
-    code: string;
-    options?: any;
-}
-interface SSHSessionParams {
-    host: string;
-    username?: string;
-    port?: number;
-    identity?: string;
-    password?: string;
-    options?: any;
-}
-interface CommandParams {
-    pid: number | string;
-    command: string;
-    options?: any;
-}
-interface IdleSessionParams {
-    maxIdleMs?: number;
-}
-/**
- * Command handler for REPL-related operations
- */
-export declare const replCommandHandler: {
-    /**
-     * Create a new REPL session
-     * @param params - Command parameters
-     * @returns Result object with session PID
-     */
-    createREPLSession: (params: REPLSessionParams) => Promise<{
-        success: boolean;
-        pid: number;
-        message: string;
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: any;
-        pid?: undefined;
-        message?: undefined;
-    }>;
-    /**
-     * Execute code in an existing REPL session
-     * @param params - Command parameters
-     * @returns Result with execution output
-     */
-    executeREPLCode: (params: ExecuteCodeParams) => Promise<any>;
-    /**
-     * Create a new SSH session
-     * @param params - Command parameters
-     * @returns Result object with session PID
-     */
-    createSSHSession: (params: SSHSessionParams) => Promise<{
-        success: boolean;
-        pid: number;
-        message: string;
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: any;
-        pid?: undefined;
-        message?: undefined;
-    }>;
-    /**
-     * Execute a command in an SSH session
-     * @param params - Command parameters
-     * @returns Result with execution output
-     */
-    executeSSHCommand: (params: CommandParams) => Promise<any>;
-    /**
-     * List all active REPL sessions
-     * @returns List of active sessions
-     */
-    listREPLSessions: () => {
-        success: boolean;
-        sessions: any[];
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: any;
-        sessions?: undefined;
-    };
-    /**
-     * Close a specific REPL session
-     * @param params - Command parameters
-     * @returns Result indicating success
-     */
-    closeREPLSession: (params: {
-        pid: number | string;
-    }) => Promise<{
-        success: boolean;
-        message: string;
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: any;
-        message?: undefined;
-    }>;
-    /**
-     * Close all idle REPL sessions
-     * @param params - Command parameters
-     * @returns Result with number of closed sessions
-     */
-    closeIdleREPLSessions: (params?: IdleSessionParams) => Promise<{
-        success: boolean;
-        closedCount: number;
-        message: string;
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: any;
-        closedCount?: undefined;
-        message?: undefined;
-    }>;
-};
-export {};

package/dist/handlers/replCommandHandler.js

@@ -1,255 +0,0 @@
-import { REPLSessionManager } from '../REPLSessionManager.js';
-let replManager = null;
-/**
- * Initialize the REPL manager with a terminal manager instance
- * @param terminalManager - The terminal manager instance
- */
-export function initializeREPLManager(terminalManager) {
-    if (!replManager) {
-        replManager = new REPLSessionManager(terminalManager);
-    }
-}
-/**
- * Command handler for REPL-related operations
- */
-export const replCommandHandler = {
-    /**
-     * Create a new REPL session
-     * @param params - Command parameters
-     * @returns Result object with session PID
-     */
-    createREPLSession: async (params) => {
-        try {
-            if (!replManager) {
-                return {
-                    success: false,
-                    error: "REPL Manager not initialized"
-                };
-            }
-            const language = params.language;
-            if (!language) {
-                return {
-                    success: false,
-                    error: "Language parameter is required"
-                };
-            }
-            const pid = await replManager.createSession(language, params.options || {});
-            return {
-                success: true,
-                pid,
-                message: `${language} REPL session started with PID ${pid}`
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error.message || "Failed to create REPL session"
-            };
-        }
-    },
-    /**
-     * Execute code in an existing REPL session
-     * @param params - Command parameters
-     * @returns Result with execution output
-     */
-    executeREPLCode: async (params) => {
-        try {
-            if (!replManager) {
-                return {
-                    success: false,
-                    error: "REPL Manager not initialized"
-                };
-            }
-            const { pid, code } = params;
-            if (!pid || !code) {
-                return {
-                    success: false,
-                    error: "Both pid and code parameters are required"
-                };
-            }
-            const result = await replManager.executeCode(typeof pid === 'string' ? parseInt(pid) : pid, code, params.options || {});
-            return {
-                success: true,
-                ...result
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error.message || "Failed to execute code in REPL session"
-            };
-        }
-    },
-    /**
-     * Create a new SSH session
-     * @param params - Command parameters
-     * @returns Result object with session PID
-     */
-    createSSHSession: async (params) => {
-        try {
-            if (!replManager) {
-                return {
-                    success: false,
-                    error: "REPL Manager not initialized"
-                };
-            }
-            const { host, username, port, identity, password } = params;
-            if (!host) {
-                return {
-                    success: false,
-                    error: "Host parameter is required"
-                };
-            }
-            const options = {
-                username,
-                port,
-                identity,
-                password,
-                ...(params.options || {})
-            };
-            const pid = await replManager.createSSHSession(host, options);
-            return {
-                success: true,
-                pid,
-                message: `SSH session to ${host} started with PID ${pid}`
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error.message || "Failed to create SSH session"
-            };
-        }
-    },
-    /**
-     * Execute a command in an SSH session
-     * @param params - Command parameters
-     * @returns Result with execution output
-     */
-    executeSSHCommand: async (params) => {
-        try {
-            if (!replManager) {
-                return {
-                    success: false,
-                    error: "REPL Manager not initialized"
-                };
-            }
-            const { pid, command } = params;
-            if (!pid || !command) {
-                return {
-                    success: false,
-                    error: "Both pid and command parameters are required"
-                };
-            }
-            // For SSH, we use the same sendAndReadREPL method but specify 'ssh' as the language
-            const parsedPid = typeof pid === 'string' ? parseInt(pid) : pid;
-            const session = replManager.listSessions().find(s => s.pid === parsedPid);
-            if (!session || session.language !== 'ssh') {
-                return {
-                    success: false,
-                    error: "Invalid SSH session PID"
-                };
-            }
-            const result = await replManager.sendAndReadREPL(parsedPid, command, 'ssh', params.options?.timeout || 10000);
-            return {
-                success: true,
-                ...result
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error.message || "Failed to execute command in SSH session"
-            };
-        }
-    },
-    /**
-     * List all active REPL sessions
-     * @returns List of active sessions
-     */
-    listREPLSessions: () => {
-        try {
-            if (!replManager) {
-                return {
-                    success: false,
-                    error: "REPL Manager not initialized"
-                };
-            }
-            const sessions = replManager.listSessions();
-            return {
-                success: true,
-                sessions
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error.message || "Failed to list REPL sessions"
-            };
-        }
-    },
-    /**
-     * Close a specific REPL session
-     * @param params - Command parameters
-     * @returns Result indicating success
-     */
-    closeREPLSession: async (params) => {
-        try {
-            if (!replManager) {
-                return {
-                    success: false,
-                    error: "REPL Manager not initialized"
-                };
-            }
-            const { pid } = params;
-            if (!pid) {
-                return {
-                    success: false,
-                    error: "PID parameter is required"
-                };
-            }
-            const parsedPid = typeof pid === 'string' ? parseInt(pid) : pid;
-            const success = await replManager.closeSession(parsedPid);
-            return {
-                success,
-                message: success
-                    ? `REPL session with PID ${pid} closed successfully`
-                    : `Failed to close REPL session with PID ${pid}`
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error.message || "Failed to close REPL session"
-            };
-        }
-    },
-    /**
-     * Close all idle REPL sessions
-     * @param params - Command parameters
-     * @returns Result with number of closed sessions
-     */
-    closeIdleREPLSessions: async (params) => {
-        try {
-            if (!replManager) {
-                return {
-                    success: false,
-                    error: "REPL Manager not initialized"
-                };
-            }
-            const maxIdleMs = params?.maxIdleMs || 30 * 60 * 1000; // Default 30 minutes
-            const closedCount = await replManager.closeIdleSessions(maxIdleMs);
-            return {
-                success: true,
-                closedCount,
-                message: `Closed ${closedCount} idle REPL session(s)`
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error.message || "Failed to close idle REPL sessions"
-            };
-        }
-    }
-};

package/dist/handlers/replCommandHandler.test.d.ts

@@ -1 +0,0 @@
-export {};