fileditor-mcp 1.0.0 → 1.0.2

package/src/handlers/readFile.js

@@ -1,109 +1,109 @@
-import { FileUtils } from '../utils/fileUtils.js';
-
-/**
- * read_file tool handler
- */
-export class ReadFileHandler {
-
-    /**
-     * Handle read_file request
-     * @param {Object} args - Request parameters
-     * @returns {Promise<Object>} Response result
-     */
-    static async handle(args) {
-        const { path, line_range } = args;
-
-        try {
-            // Check if single file or multiple files
-            if (Array.isArray(path)) {
-                // Read multiple files
-                return await ReadFileHandler.readMultipleFiles(path);
-            } else {
-                // Read single file
-                return await ReadFileHandler.readSingleFile(path, line_range);
-            }
-        } catch (error) {
-            throw new Error(`Failed to read file(s): ${error.message}`);
-        }
-    }
-
-    /**
-     * Read a single file
-     * @param {string} filePath - File path
-     * @param {string} line_range - Line range
-     * @returns {Promise<Object>} Response result
-     */
-    static async readSingleFile(filePath, line_range) {
-        const content = await FileUtils.readFile(filePath);
-
-        if (line_range) {
-            const selectedContent = FileUtils.getLineRange(content, line_range);
-            const [startLine] = line_range.split('-').map(Number);
-            const formattedContent = FileUtils.formatWithLineNumbers(selectedContent, startLine);
-            return FileUtils.createResponse(formattedContent);
-        }
-
-        const formattedContent = FileUtils.formatWithLineNumbers(content);
-        return FileUtils.createResponse(formattedContent);
-    }
-
-    /**
-     * Read multiple files
-     * @param {string[]} filePaths - Array of file paths
-     * @returns {Promise<Object>} Response result
-     */
-    static async readMultipleFiles(filePaths) {
-        // Check for empty array
-        if (!Array.isArray(filePaths) || filePaths.length === 0) {
-            throw new Error('Failed to read any files: No files provided');
-        }
-
-        const results = [];
-        const errors = [];
-
-        for (const filePath of filePaths) {
-            try {
-                if (!FileUtils.fileExists(filePath)) {
-                    errors.push(`File not found: ${filePath}`);
-                    continue;
-                }
-
-                const content = await FileUtils.readFile(filePath);
-                results.push({
-                    file: filePath,
-                    content: content,
-                    lines: FileUtils.countLines(content)
-                });
-            } catch (error) {
-                errors.push(`Error reading ${filePath}: ${error.message}`);
-            }
-        }
-
-        // Build return content
-        let responseText = '';
-
-        if (results.length > 0) {
-            responseText += `Successfully read ${results.length} file(s):\n\n`;
-
-            for (const result of results) {
-                responseText += `=== ${result.file} (${result.lines} lines) ===\n`;
-                const formattedContent = FileUtils.formatWithLineNumbers(result.content);
-                responseText += formattedContent;
-                responseText += '\n\n';
-            }
-        }
-
-        if (errors.length > 0) {
-            responseText += `Errors encountered:\n`;
-            for (const error of errors) {
-                responseText += `- ${error}\n`;
-            }
-        }
-
-        if (results.length === 0 && errors.length > 0) {
-            throw new Error(`Failed to read any files: ${errors.join(', ')}`);
-        }
-
-        return FileUtils.createResponse(responseText.trim());
-    }
-}
+import { FileUtils } from '../utils/fileUtils.js';
+
+/**
+ * read_file tool handler
+ */
+export class ReadFileHandler {
+
+    /**
+     * Handle read_file request
+     * @param {Object} args - Request parameters
+     * @returns {Promise<Object>} Response result
+     */
+    static async handle(args) {
+        const { path, line_range } = args;
+
+        try {
+            // Check if single file or multiple files
+            if (Array.isArray(path)) {
+                // Read multiple files
+                return await ReadFileHandler.readMultipleFiles(path);
+            } else {
+                // Read single file
+                return await ReadFileHandler.readSingleFile(path, line_range);
+            }
+        } catch (error) {
+            throw new Error(`Failed to read file(s): ${error.message}`);
+        }
+    }
+
+    /**
+     * Read a single file
+     * @param {string} filePath - File path
+     * @param {string} line_range - Line range
+     * @returns {Promise<Object>} Response result
+     */
+    static async readSingleFile(filePath, line_range) {
+        const content = await FileUtils.readFile(filePath);
+
+        if (line_range) {
+            const selectedContent = FileUtils.getLineRange(content, line_range);
+            const [startLine] = line_range.split('-').map(Number);
+            const formattedContent = FileUtils.formatWithLineNumbers(selectedContent, startLine);
+            return FileUtils.createResponse(formattedContent);
+        }
+
+        const formattedContent = FileUtils.formatWithLineNumbers(content);
+        return FileUtils.createResponse(formattedContent);
+    }
+
+    /**
+     * Read multiple files
+     * @param {string[]} filePaths - Array of file paths
+     * @returns {Promise<Object>} Response result
+     */
+    static async readMultipleFiles(filePaths) {
+        // Check for empty array
+        if (!Array.isArray(filePaths) || filePaths.length === 0) {
+            throw new Error('Failed to read any files: No files provided');
+        }
+
+        const results = [];
+        const errors = [];
+
+        for (const filePath of filePaths) {
+            try {
+                if (!FileUtils.fileExists(filePath)) {
+                    errors.push(`File not found: ${filePath}`);
+                    continue;
+                }
+
+                const content = await FileUtils.readFile(filePath);
+                results.push({
+                    file: filePath,
+                    content: content,
+                    lines: FileUtils.countLines(content)
+                });
+            } catch (error) {
+                errors.push(`Error reading ${filePath}: ${error.message}`);
+            }
+        }
+
+        // Build return content
+        let responseText = '';
+
+        if (results.length > 0) {
+            responseText += `Successfully read ${results.length} file(s):\n\n`;
+
+            for (const result of results) {
+                responseText += `=== ${result.file} (${result.lines} lines) ===\n`;
+                const formattedContent = FileUtils.formatWithLineNumbers(result.content);
+                responseText += formattedContent;
+                responseText += '\n\n';
+            }
+        }
+
+        if (errors.length > 0) {
+            responseText += `Errors encountered:\n`;
+            for (const error of errors) {
+                responseText += `- ${error}\n`;
+            }
+        }
+
+        if (results.length === 0 && errors.length > 0) {
+            throw new Error(`Failed to read any files: ${errors.join(', ')}`);
+        }
+
+        return FileUtils.createResponse(responseText.trim());
+    }
+}

package/src/handlers/searchAndReplace.js

@@ -1,198 +1,217 @@
-import { FileUtils } from '../utils/fileUtils.js';
-
-/**
- * search_and_replace tool handler
- */
-export class SearchAndReplaceHandler {
-
-    /**
-     * Handle search_and_replace request
-     * @param {Object} args - Request parameters
-     * @returns {Promise<Object>} Response result
-     */
-    static async handle(args) {
-        const {
-            path,
-            search,
-            replace,
-            use_regex = false,
-            ignore_case = false,
-            start_line = null,
-            end_line = null
-        } = args;
-
-        try {
-            // Check if file exists
-            if (!FileUtils.fileExists(path)) {
-                throw new Error(`File not found: ${path}`);
-            }
-
-            // Read file content
-            const content = await FileUtils.readFile(path);
-            const lines = content.split('\n');            // Determine search range
-            const startIdx = start_line !== null ? Math.max(0, start_line - 1) : 0;
-            const endIdx = end_line !== null ? Math.min(lines.length, end_line) : lines.length;            // Validate search string
-            if (!search) {
-                // Empty search string, do not perform any replacement
-                let message = `Successfully replaced 0 occurrence(s) in ${path}`;
-                if (start_line || end_line) {
-                    const rangeDesc = start_line && end_line
-                        ? `lines ${start_line}-${end_line}`
-                        : start_line
-                            ? `from line ${start_line}`
-                            : `up to line ${end_line}`;
-                    message += ` (${rangeDesc})`;
-                }
-                return FileUtils.createResponse(message);
-            }
-            if (start_line !== null && start_line < 1) {
-                throw new Error(`Invalid start_line: ${start_line}. Line numbers start from 1.`);
-            }
-            if (end_line !== null && end_line < 1) {
-                throw new Error(`Invalid end_line: ${end_line}. Line numbers start from 1.`);
-            } if (start_line !== null && end_line !== null && start_line > end_line) {
-                throw new Error(`start_line (${start_line}) cannot be greater than end_line (${end_line})`);
-            }
-            if (start_line !== null && start_line > lines.length) {
-                throw new Error(`start_line (${start_line}) exceeds file length (${lines.length} lines)`);
-            }
-
-            // Perform search and replace
-            let replacementCount = 0;
-            const searchLines = lines.slice(startIdx, endIdx);
-            const beforeLines = lines.slice(0, startIdx);
-            const afterLines = lines.slice(endIdx);
-
-            const processedLines = searchLines.map(line => {
-                let newLine;
-
-                if (use_regex) {
-                    try {
-                        // Build regex flags
-                        let flags = 'g';
-                        if (ignore_case) {
-                            flags += 'i';
-                        }
-
-                        const regex = new RegExp(search, flags);
-                        const matches = line.match(regex);
-                        if (matches) {
-                            replacementCount += matches.length;
-                        }
-                        newLine = line.replace(regex, replace);
-                    } catch (error) {
-                        throw new Error(`Invalid regular expression: ${search}. ${error.message}`);
-                    }
-                } else {
-                    // Simple string replacement
-                    if (ignore_case) {
-                        // Case-insensitive string replacement
-                        const searchLower = search.toLowerCase();
-                        const lineLower = line.toLowerCase();
-
-                        // Count occurrences
-                        const occurrences = SearchAndReplaceHandler.countOccurrencesCaseInsensitive(line, search);
-                        replacementCount += occurrences;
-
-                        // Perform replacement
-                        newLine = SearchAndReplaceHandler.replaceAllCaseInsensitive(line, search, replace);
-                    } else {
-                        // Case-sensitive string replacement
-                        const occurrences = SearchAndReplaceHandler.countOccurrences(line, search);
-                        replacementCount += occurrences;
-                        newLine = line.split(search).join(replace);
-                    }
-                }
-
-                return newLine;
-            });
-
-            // Rebuild file content
-            const newContent = [...beforeLines, ...processedLines, ...afterLines].join('\n');
-
-            // Write back to file
-            await FileUtils.writeFile(path, newContent);
-
-            // Build response message
-            let message = `Successfully replaced ${replacementCount} occurrence(s) in ${path}`;
-
-            if (start_line || end_line) {
-                const rangeDesc = start_line && end_line
-                    ? `lines ${start_line}-${end_line}`
-                    : start_line
-                        ? `from line ${start_line}`
-                        : `up to line ${end_line}`;
-                message += ` (${rangeDesc})`;
-            }
-
-            if (use_regex) {
-                message += ` using regex pattern`;
-            }
-
-            if (ignore_case) {
-                message += ` (case-insensitive)`;
-            }
-
-            return FileUtils.createResponse(message);
-
-        } catch (error) {
-            throw new Error(`Failed to search and replace: ${error.message}`);
-        }
-    }
-
-    /**
-     * Count occurrences of a substring in a string
-     * @param {string} text - Main string
-     * @param {string} searchText - Substring to search for
-     * @returns {number} Number of occurrences
-     */
-    static countOccurrences(text, searchText) {
-        if (!searchText) return 0;
-        return text.split(searchText).length - 1;
-    }
-
-    /**
-     * Count occurrences of a substring in a string (case-insensitive)
-     * @param {string} text - Main string
-     * @param {string} searchText - Substring to search for
-     * @returns {number} Number of occurrences
-     */
-    static countOccurrencesCaseInsensitive(text, searchText) {
-        if (!searchText) return 0;
-        const textLower = text.toLowerCase();
-        const searchLower = searchText.toLowerCase();
-        return textLower.split(searchLower).length - 1;
-    }    /**
-     * Case-insensitive string replacement
-     * @param {string} text - Main string
-     * @param {string} searchText - Substring to search for
-     * @param {string} replaceText - Replacement text
-     * @returns {string} Replaced string
-     */
-    static replaceAllCaseInsensitive(text, searchText, replaceText) {
-        if (!searchText) return text;
-
-        const searchLower = searchText.toLowerCase();
-        const textLower = text.toLowerCase();
-
-        let result = '';
-        let lastIndex = 0;
-
-        let index = textLower.indexOf(searchLower);
-        while (index !== -1) {
-            // Add part before match
-            result += text.slice(lastIndex, index);
-            // Add replacement text
-            result += replaceText;
-            // Update position
-            lastIndex = index + searchText.length;
-            // Find next match
-            index = textLower.indexOf(searchLower, lastIndex);
-        }
-
-        // Add remaining part
-        result += text.slice(lastIndex);
-
-        return result;
-    }
-}
+import { FileUtils } from '../utils/fileUtils.js';
+
+/**
+ * search_and_replace tool handler
+ */
+export class SearchAndReplaceHandler {
+
+    /**
+     * Handle search_and_replace request
+     * @param {Object} args - Request parameters
+     * @returns {Promise<Object>} Response result
+     */
+    static async handle(args) {
+        const {
+            path,
+            search,
+            replace,
+            use_regex = false,
+            ignore_case = false,
+            start_line = null,
+            end_line = null
+        } = args;
+
+        try {
+            // Check if file exists
+            if (!FileUtils.fileExists(path)) {
+                throw new Error(`File not found: ${path}`);
+            }
+
+            // Read file content
+            const content = await FileUtils.readFile(path);
+            const lines = content.split('\n');
+
+            // Validate line range
+            FileUtils.validateLineRange({
+                start_line,
+                end_line,
+                totalLines: lines.length
+            });
+
+            // Determine search range
+            const startIdx = start_line !== null ? Math.max(0, start_line - 1) : 0;
+            const endIdx = end_line !== null ? Math.min(lines.length, end_line) : lines.length;
+
+            // Validate search string
+            if (!search) {
+                // Empty search string, do not perform any replacement
+                const message = SearchAndReplaceHandler._buildResultMessage(path, 0, start_line, end_line, use_regex, ignore_case);
+                return FileUtils.createResponse(message);
+            }
+
+            // Perform search and replace
+            const { processedLines, replacementCount } = SearchAndReplaceHandler._performSearchAndReplace(
+                lines.slice(startIdx, endIdx),
+                search,
+                replace,
+                use_regex,
+                ignore_case
+            );
+
+            // Rebuild file content
+            const newContent = [
+                ...lines.slice(0, startIdx),
+                ...processedLines,
+                ...lines.slice(endIdx)
+            ].join('\n');
+
+            // Write back to file
+            await FileUtils.writeFile(path, newContent);
+
+            // Build response message
+            const message = SearchAndReplaceHandler._buildResultMessage(path, replacementCount, start_line, end_line, use_regex, ignore_case);
+            return FileUtils.createResponse(message);
+
+        } catch (error) {
+            throw new Error(`Failed to search and replace: ${error.message}`);
+        }
+    }
+
+    /**
+     * Perform search and replace operation
+     * @param {string[]} lines - Lines to process
+     * @param {string} search - Search pattern
+     * @param {string} replace - Replacement text
+     * @param {boolean} use_regex - Whether to use regex
+     * @param {boolean} ignore_case - Whether to ignore case
+     * @returns {Object} Processing result
+     */
+    static _performSearchAndReplace(lines, search, replace, use_regex, ignore_case) {
+        let replacementCount = 0;
+
+        const processedLines = lines.map(line => {
+            let newLine;
+
+            if (use_regex) {
+                const { processedLine, count } = SearchAndReplaceHandler._regexReplace(line, search, replace, ignore_case);
+                newLine = processedLine;
+                replacementCount += count;
+            } else {
+                const { processedLine, count } = SearchAndReplaceHandler._stringReplace(line, search, replace, ignore_case);
+                newLine = processedLine;
+                replacementCount += count;
+            }
+
+            return newLine;
+        });
+
+        return { processedLines, replacementCount };
+    }
+
+    /**
+     * Perform regex-based replacement
+     * @param {string} line - Line to process
+     * @param {string} search - Regex pattern
+     * @param {string} replace - Replacement text
+     * @param {boolean} ignore_case - Whether to ignore case
+     * @returns {Object} Result with processed line and count
+     */
+    static _regexReplace(line, search, replace, ignore_case) {
+        try {
+            // Build regex flags
+            let flags = 'g';
+            if (ignore_case) {
+                flags += 'i';
+            }
+
+            const regex = new RegExp(search, flags);
+            const matches = line.match(regex);
+            const count = matches ? matches.length : 0;
+            const processedLine = line.replace(regex, replace);
+
+            return { processedLine, count };
+        } catch (error) {
+            throw new Error(`Invalid regular expression: ${search}. ${error.message}`);
+        }
+    }
+
+    /**
+     * Perform string-based replacement
+     * @param {string} line - Line to process
+     * @param {string} search - Search string
+     * @param {string} replace - Replacement text
+     * @param {boolean} ignore_case - Whether to ignore case
+     * @returns {Object} Result with processed line and count
+     */
+    static _stringReplace(line, search, replace, ignore_case) {
+        if (ignore_case) {
+            // Use regex for case-insensitive string replacement
+            const escapedSearch = SearchAndReplaceHandler._escapeRegex(search);
+            const regex = new RegExp(escapedSearch, 'gi');
+            const matches = line.match(regex);
+            const count = matches ? matches.length : 0;
+            const processedLine = line.replace(regex, replace);
+
+            return { processedLine, count };
+        } else {
+            // Case-sensitive string replacement
+            const count = SearchAndReplaceHandler._countOccurrences(line, search);
+            const processedLine = line.split(search).join(replace);
+
+            return { processedLine, count };
+        }
+    }
+
+    /**
+     * Escape special regex characters in a string
+     * @param {string} string - String to escape
+     * @returns {string} Escaped string
+     */
+    static _escapeRegex(string) {
+        return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+
+    /**
+     * Count occurrences of a substring in a string
+     * @param {string} text - Main string
+     * @param {string} searchText - Substring to search for
+     * @returns {number} Number of occurrences
+     */
+    static _countOccurrences(text, searchText) {
+        if (!searchText) return 0;
+        return text.split(searchText).length - 1;
+    }
+
+    /**
+     * Build result message
+     * @param {string} path - File path
+     * @param {number} replacementCount - Number of replacements
+     * @param {number|null} start_line - Start line
+     * @param {number|null} end_line - End line  
+     * @param {boolean} use_regex - Whether regex was used
+     * @param {boolean} ignore_case - Whether case was ignored
+     * @returns {string} Result message
+     */
+    static _buildResultMessage(path, replacementCount, start_line, end_line, use_regex, ignore_case) {
+        let message = `Successfully replaced ${replacementCount} occurrence(s) in ${path}`;
+
+        if (start_line || end_line) {
+            const rangeDesc = start_line && end_line
+                ? `lines ${start_line}-${end_line}`
+                : start_line
+                    ? `from line ${start_line}`
+                    : `up to line ${end_line}`;
+            message += ` (${rangeDesc})`;
+        }
+
+        if (use_regex) {
+            message += ` using regex pattern`;
+        }
+
+        if (ignore_case) {
+            message += ` (case-insensitive)`;
+        }
+
+        return message;
+    }
+}