fileditor-mcp 1.0.0

package/src/handlers/listFiles.js

@@ -0,0 +1,65 @@
+import fs from 'fs/promises';
+import { resolve, join } from 'path';
+import { existsSync } from 'fs';
+import { FileUtils } from '../utils/fileUtils.js';
+
+/**
+ * list_files tool handler
+ */
+export class ListFilesHandler {
+
+    /**
+     * Handle list_files request
+     * @param {Object} args - Request parameters
+     * @returns {Promise<Object>} Response result
+     */
+    static async handle(args) {
+        const { path, recursive = false } = args;
+
+        try {
+            const fullPath = FileUtils.getSecurePath(path);
+
+            if (!existsSync(fullPath)) {
+                throw new Error(`Directory not found: ${path}`);
+            }
+
+            const result = [];
+
+            if (recursive) {
+                await ListFilesHandler.listFilesRecursive(fullPath, result, '');
+            } else {
+                const items = await fs.readdir(fullPath, { withFileTypes: true });
+                for (const item of items) {
+                    const type = item.isDirectory() ? 'directory' : 'file';
+                    result.push(`${type}: ${item.name}`);
+                }
+            }
+
+            return FileUtils.createResponse(result.join('\n'));
+        } catch (error) {
+            throw new Error(`Failed to list files: ${error.message}`);
+        }
+    }
+
+    /**
+     * Recursively list files
+     * @param {string} dirPath - Directory path
+     * @param {string[]} result - Result array
+     * @param {string} prefix - Path prefix
+     */
+    static async listFilesRecursive(dirPath, result, prefix) {
+        const items = await fs.readdir(dirPath, { withFileTypes: true });
+
+        for (const item of items) {
+            const itemPath = join(dirPath, item.name);
+            const displayPath = prefix ? `${prefix}/${item.name}` : item.name;
+
+            if (item.isDirectory()) {
+                result.push(`directory: ${displayPath}`);
+                await ListFilesHandler.listFilesRecursive(itemPath, result, displayPath);
+            } else {
+                result.push(`file: ${displayPath}`);
+            }
+        }
+    }
+}

package/src/handlers/readFile.js

@@ -0,0 +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());
+    }
+}

package/src/handlers/searchAndReplace.js

@@ -0,0 +1,198 @@
+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;
+    }
+}

package/src/handlers/setWorkspace.js

@@ -0,0 +1,26 @@
+import { FileUtils } from '../utils/fileUtils.js';
+
+/**
+ * set_workspace tool handler
+ */
+export class SetWorkspaceHandler {
+
+    /**
+     * Handle set_workspace request
+     * @param {Object} args - Request parameters
+     * @returns {Promise<Object>} Response result
+     */
+    static async handle(args) {
+        const { path } = args;
+
+        try {
+            // Set new workspace root directory
+            FileUtils.setWorkspaceRoot(path);
+
+            const message = `Successfully set workspace root to: ${FileUtils.getWorkspaceRoot()}`;
+            return FileUtils.createResponse(message);
+        } catch (error) {
+            throw new Error(`Failed to set workspace: ${error.message}`);
+        }
+    }
+}

package/src/handlers/writeFile.js

@@ -0,0 +1,98 @@
+import { FileUtils } from '../utils/fileUtils.js';
+
+/**
+ * write_files tool handler
+ */
+export class WriteFileHandler {
+
+    /**
+     * Handle write_files request
+     * @param {Object} args - Request parameters
+     * @returns {Promise<Object>} Response result
+     */
+    static async handle(args) {
+        const { path, content, line_count } = args;
+
+        try {
+            // Handle single file or multiple files
+            const paths = Array.isArray(path) ? path : [path];
+            const contents = Array.isArray(content) ? content : [content];
+            const lineCounts = Array.isArray(line_count) ? line_count : [line_count];
+
+            // Validate array length consistency
+            if (Array.isArray(path)) {
+                if (Array.isArray(content) && contents.length !== paths.length) {
+                    throw new Error(`Path count (${paths.length}) doesn't match content count (${contents.length})`);
+                }
+                if (Array.isArray(line_count) && lineCounts.length !== paths.length) {
+                    throw new Error(`Path count (${paths.length}) doesn't match line_count array length (${lineCounts.length})`);
+                }
+            }
+
+            const results = [];
+            const writeOperations = [];
+
+            // Perform all write operations
+            for (let i = 0; i < paths.length; i++) {
+                const filePath = paths[i];
+                const fileContent = Array.isArray(content) ? contents[i] : content;
+                const expectedLines = Array.isArray(line_count) ? lineCounts[i] : line_count;
+
+                // Execute write operations in parallel
+                writeOperations.push(
+                    FileUtils.writeFile(filePath, fileContent).then(() => {
+                        // Validate line count
+                        const actualLines = FileUtils.countLines(fileContent);
+                        if (actualLines !== expectedLines) {
+                            console.warn(`Warning: ${filePath} - Expected ${expectedLines} lines, but got ${actualLines} lines`);
+                        }
+
+                        return {
+                            path: filePath,
+                            actualLines,
+                            expectedLines,
+                            success: true
+                        };
+                    }).catch(error => {
+                        return {
+                            path: filePath,
+                            success: false,
+                            error: error.message
+                        };
+                    })
+                );
+            }
+
+            // Wait for all write operations to complete
+            const writeResults = await Promise.all(writeOperations);
+
+            // Check for failed operations
+            const failures = writeResults.filter(result => !result.success);
+            if (failures.length > 0) {
+                const errorMessages = failures.map(f => `${f.path}: ${f.error}`);
+                throw new Error(`Failed to write ${failures.length} file(s): ${errorMessages.join(', ')}`);
+            }
+
+            // Build success message
+            const successResults = writeResults.filter(result => result.success);
+            const totalFiles = successResults.length;
+            const totalLines = successResults.reduce((sum, result) => sum + result.actualLines, 0);
+
+            let message;
+            if (totalFiles === 1) {
+                const result = successResults[0];
+                message = `File written successfully: ${result.path} (${result.actualLines} lines)`;
+            } else {
+                message = `Successfully wrote ${totalFiles} files (${totalLines} total lines):\n` +
+                    successResults.map(result =>
+                        `  - ${result.path} (${result.actualLines} lines)`
+                    ).join('\n');
+            }
+
+            return FileUtils.createResponse(message);
+
+        } catch (error) {
+            throw new Error(`Failed to write file(s): ${error.message}`);
+        }
+    }
+}

package/src/index.js

@@ -0,0 +1,20 @@
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { FileEditorMCPServer } from './server.js';
+
+/**
+ * Entry point for FileEditor MCP server
+ */
+async function main() {
+    try {
+        const server = new FileEditorMCPServer();
+        const transport = new StdioServerTransport();
+
+        await server.start(transport);
+    } catch (error) {
+        console.error("Failed to start FileEditor MCP server:", error);
+        process.exit(1);
+    }
+}
+
+// Start the server
+main();

package/src/server.js

@@ -0,0 +1,85 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import {
+    CallToolRequestSchema,
+    ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+
+import { toolDefinitions } from './tools/toolDefinitions.js';
+import { SetWorkspaceHandler } from './handlers/setWorkspace.js';
+import { ReadFileHandler } from './handlers/readFile.js';
+import { WriteFileHandler } from './handlers/writeFile.js';
+import { ListFilesHandler } from './handlers/listFiles.js';
+import { InsertContentHandler } from './handlers/insertContent.js';
+import { ApplyDiffHandler } from './handlers/applyDiff.js';
+import { SearchAndReplaceHandler } from './handlers/searchAndReplace.js';
+import { FileUtils } from './utils/fileUtils.js';
+
+/**
+ * Main class for FileEditor MCP server
+ */
+export class FileEditorMCPServer {
+    constructor() {
+        this.server = new Server(
+            {
+                name: "fileditor-mcp",
+                version: "1.0.0",
+            },
+            {
+                capabilities: {
+                    tools: {},
+                },
+            }
+        );
+
+        this.setupHandlers();
+    }
+
+    /**
+     * Set up request handlers
+     */
+    setupHandlers() {
+        // List available tools
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+            return {
+                tools: toolDefinitions
+            };
+        });
+
+        // Handle tool calls
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            try {
+                const { name, arguments: args } = request.params;
+
+                switch (name) {
+                    case "set_workspace":
+                        return await SetWorkspaceHandler.handle(args);
+                    case "read_files":
+                        return await ReadFileHandler.handle(args);
+                    case "write_files":
+                        return await WriteFileHandler.handle(args);
+                    case "list_files":
+                        return await ListFilesHandler.handle(args);
+                    case "insert_contents":
+                        return await InsertContentHandler.handle(args);
+                    case "apply_diffs":
+                        return await ApplyDiffHandler.handle(args);
+                    case "search_and_replace":
+                        return await SearchAndReplaceHandler.handle(args);
+                    default:
+                        throw new Error(`Unknown tool: ${name}`);
+                }
+            } catch (error) {
+                return FileUtils.createErrorResponse(error.message);
+            }
+        });
+    }
+
+    /**
+     * Start the server
+     * @param {Object} transport - Transport object
+     */
+    async start(transport) {
+        await this.server.connect(transport);
+        console.error("FileEditor MCP server running on stdio");
+    }
+}