fileditor-mcp 1.0.0

package/src/tools/toolDefinitions.js

@@ -0,0 +1,291 @@
+// Tool definitions and Schema configuration
+export const toolDefinitions = [
+    {
+        name: "set_workspace",
+        description: "Set the workspace root directory. All relative path operations will be based on this directory. You must call this tool to set the correct workspace before performing any file operations.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: {
+                    type: "string",
+                    description: "The absolute path to the workspace root directory (e.g., the directory opened by VSCode)"
+                }
+            },
+            required: ["path"]
+        }
+    },
+    {
+        name: "read_files",
+        description: "Read the entire or partial content of the specified file(s). Supports reading single or multiple files at once. The returned content includes line numbers in the format 'line | content'.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: {
+                    oneOf: [
+                        {
+                            type: "string",
+                            description: "The path of the single file to read. The path can be an absolute path or a workspace-relative path."
+                        },
+                        {
+                            type: "array",
+                            items: {
+                                type: "string"
+                            },
+                            description: "An array of file paths to read. Each path can be an absolute path or a workspace-relative path."
+                        }
+                    ]
+                },
+                line_range: {
+                    type: "string",
+                    description: "Optional line range, format 'start-end' (only for single file)",
+                    pattern: "^\\d+-\\d+$"
+                }
+            },
+            required: ["path"]
+        }
+    },
+    {
+        name: "write_files",
+        description: "Create new files or completely overwrite existing files. Supports single or multiple files at once.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: {
+                    oneOf: [
+                        {
+                            type: "string",
+                            description: "The path of the single target file. The path can be an absolute path or a workspace-relative path."
+                        },
+                        {
+                            type: "array",
+                            items: {
+                                type: "string"
+                            },
+                            description: "An array of target file paths. Each path can be an absolute path or a workspace-relative path."
+                        }
+                    ]
+                },
+                content: {
+                    oneOf: [
+                        {
+                            type: "string",
+                            description: "The full content to write, for single file or same content for all files"
+                        },
+                        {
+                            type: "array",
+                            items: {
+                                type: "string"
+                            },
+                            description: "An array of content for each file, for different content per file"
+                        }
+                    ]
+                },
+                line_count: {
+                    oneOf: [
+                        {
+                            type: "integer",
+                            description: "Total number of lines in the file, for single file or same for all files",
+                            minimum: 0
+                        },
+                        {
+                            type: "array",
+                            items: {
+                                type: "integer",
+                                minimum: 0
+                            },
+                            description: "An array of line counts for each file, for different line counts per file"
+                        }
+                    ]
+                }
+            },
+            required: ["path", "content", "line_count"]
+        }
+    },
+    {
+        name: "list_files",
+        description: "List the files and subdirectories in the specified directory.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: {
+                    type: "string",
+                    description: "The directory path to list contents of. The path can be an absolute path or a workspace-relative path."
+                },
+                recursive: {
+                    type: "boolean",
+                    description: "Whether to recursively list subdirectory contents",
+                    default: false
+                }
+            },
+            required: ["path"]
+        }
+    },
+    {
+        name: "insert_contents",
+        description: "Insert new content at the specified position in the file. Supports editing single or multiple files at once. Negative line numbers are supported for insertion from the end.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: {
+                    oneOf: [
+                        {
+                            type: "string",
+                            description: "The path of the single target file. The path can be an absolute path or a workspace-relative path."
+                        },
+                        {
+                            type: "array",
+                            items: {
+                                type: "string"
+                            },
+                            description: "An array of target file paths. Each path can be an absolute path or a workspace-relative path."
+                        }
+                    ]
+                },
+                line: {
+                    oneOf: [
+                        {
+                            type: "integer",
+                            description: "The line number to insert (positive: 1-based, 0: end of file, negative: from end, -1 before last line), for single file"
+                        },
+                        {
+                            type: "array",
+                            items: {
+                                type: "integer"
+                            },
+                            description: "An array of line numbers for each file (positive: insert, 0: end, negative: from end), for multiple files"
+                        }
+                    ]
+                },
+                content: {
+                    oneOf: [
+                        {
+                            type: "string",
+                            description: "The content to insert, for single file or same content for all files"
+                        },
+                        {
+                            type: "array",
+                            items: {
+                                type: "string"
+                            },
+                            description: "An array of content for each file, for different content per file"
+                        }
+                    ]
+                }
+            },
+            required: ["path", "line", "content"]
+        }
+    },
+    {
+        name: "apply_diffs",
+        description: "Perform precise block-based search and replace operations on existing files. Supports single or multiple diff operations on a single file. When processing multiple diffs, the tool automatically handles line number offsets - all start_line values should be based on the original file structure. By default, operates in atomic mode for safe batch operations.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: {
+                    type: "string",
+                    description: "The path of the file to modify. The path can be an absolute path or a workspace-relative path."
+                },
+                search_content: {
+                    oneOf: [
+                        {
+                            type: "string",
+                            description: "The original content to match precisely (for single diff)"
+                        },
+                        {
+                            type: "array",
+                            items: {
+                                type: "string"
+                            },
+                            description: "Array of original content to match precisely (for multiple diffs)"
+                        }
+                    ]
+                },
+                replace_content: {
+                    oneOf: [
+                        {
+                            type: "string",
+                            description: "The new content to replace with (for single diff)"
+                        },
+                        {
+                            type: "array",
+                            items: {
+                                type: "string"
+                            },
+                            description: "Array of new content to replace with (for multiple diffs)"
+                        }
+                    ]
+                },
+                start_line: {
+                    oneOf: [
+                        {
+                            type: "integer",
+                            description: "The starting line number for searching content (for single diff, 1-based line number from original file)",
+                            minimum: 1
+                        },
+                        {
+                            type: "array",
+                            items: {
+                                type: "integer",
+                                minimum: 1
+                            },
+                            description: "Array of starting line numbers for searching content (for multiple diffs, all 1-based line numbers from original file - tool automatically handles line offset adjustments during processing)"
+                        }
+                    ]
+                },
+                atomic: {
+                    type: "boolean",
+                    description: "Whether to use atomic mode (all-or-nothing). When true (default), validates all diffs before applying any. When false, applies diffs one by one, continuing on failures.",
+                    default: true
+                },
+                trim: {
+                    type: "boolean",
+                    description: "Whether to trim whitespace from the beginning and end of each line when comparing search_content with file content. Only affects search and matching - replace_content is inserted exactly as provided. Default is false.",
+                    default: false
+                }
+            },
+            required: ["path", "search_content", "replace_content", "start_line"]
+        }
+    },
+    {
+        name: "search_and_replace",
+        description: "Search and replace text or regular expressions in a single file.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: {
+                    type: "string",
+                    description: "The target file path. The path can be an absolute path or a workspace-relative path."
+                },
+                search: {
+                    type: "string",
+                    description: "The text or regular expression to search for"
+                },
+                replace: {
+                    type: "string",
+                    description: "The text to replace with"
+                },
+                use_regex: {
+                    type: "boolean",
+                    description: "Whether to use regular expressions for searching",
+                    default: false
+                },
+                ignore_case: {
+                    type: "boolean",
+                    description: "Whether to ignore case when searching",
+                    default: false
+                },
+                start_line: {
+                    type: "integer",
+                    description: "The starting line of the search range",
+                    minimum: 1
+                },
+                end_line: {
+                    type: "integer",
+                    description: "The ending line of the search range",
+                    minimum: 1
+                }
+            },
+            required: ["path", "search", "replace"]
+        }
+    }
+];

package/src/utils/fileUtils.js

@@ -0,0 +1,238 @@
+import fs from 'fs/promises';
+import { resolve, dirname, isAbsolute, join } from 'path';
+import { existsSync, lstatSync } from 'fs';
+import { cwd } from 'process';
+import pathIsInside from 'path-is-inside';
+
+/**
+ * General file operation utility class
+ */
+export class FileUtils {
+
+    // Current workspace root directory, initially null, must be set via set_workspace
+    static WORKSPACE_ROOT = null;    /**
+     * Set workspace root directory
+     * @param {string} workspaceRoot - New workspace root directory path
+     * @throws {Error} If directory does not exist or is not accessible
+     */
+    static setWorkspaceRoot(workspaceRoot) {
+        // Input validation
+        if (!workspaceRoot || typeof workspaceRoot !== 'string') {
+            throw new Error('Invalid workspace root: must be a non-empty string');
+        }
+
+        // Prevent null bytes and other dangerous characters
+        if (workspaceRoot.includes('\0') || workspaceRoot.includes('\x00')) {
+            throw new Error('Invalid workspace root: contains null bytes');
+        }
+
+        const resolvedPath = resolve(workspaceRoot);
+
+        if (!existsSync(resolvedPath)) {
+            throw new Error(`Workspace directory does not exist: ${workspaceRoot}`);
+        }        // Verify it is a directory, not a file
+        try {
+            const stats = lstatSync(resolvedPath);
+            if (!stats.isDirectory()) {
+                throw new Error(`Workspace path is not a directory: ${workspaceRoot}`);
+            }
+        } catch (error) {
+            if (error.code !== 'ENOENT') {
+                throw new Error(`Cannot access workspace directory: ${error.message}`);
+            }
+        }
+
+        FileUtils.WORKSPACE_ROOT = resolvedPath;
+        console.error(`Workspace root set to: ${FileUtils.WORKSPACE_ROOT}`);
+    }
+
+    /**
+     * Get current workspace root directory
+     * @returns {string} Current workspace root directory
+     */
+    static getWorkspaceRoot() {
+        return FileUtils.WORKSPACE_ROOT;
+    }
+
+    /**
+     * Securely resolve file path, ensuring it does not go outside the workspace
+     * Uses a mature third-party library to prevent path traversal attacks
+     * @param {string} filePath - Input file path
+     * @returns {string} Secure absolute path
+     * @throws {Error} If path tries to access files outside the workspace or workspace is not set
+     */
+    static getSecurePath(filePath) {
+        // First check if workspace is set
+        if (!FileUtils.WORKSPACE_ROOT) {
+            throw new Error('Workspace not set. Please call set_workspace first to establish a secure workspace root directory.');
+        }
+
+        // Input validation
+        if (!filePath || typeof filePath !== 'string') {
+            throw new Error('Invalid file path: must be a non-empty string');
+        }
+
+        // Prevent null bytes and other dangerous characters
+        if (filePath.includes('\0') || filePath.includes('\x00')) {
+            throw new Error('Invalid file path: contains null bytes');
+        }
+
+        let targetPath;
+
+        if (isAbsolute(filePath)) {
+            // Absolute path: use directly
+            targetPath = filePath;
+        } else {
+            // Relative path: join to workspace root
+            targetPath = join(FileUtils.WORKSPACE_ROOT, filePath);
+        }
+
+        // Resolve to canonical absolute path, handle symlinks
+        let resolvedPath;
+        try {
+            resolvedPath = resolve(targetPath);
+        } catch (error) {
+            throw new Error(`Failed to resolve path '${filePath}': ${error.message}`);
+        }
+
+        // Use mature third-party library to check if path is inside workspace
+        if (!pathIsInside(resolvedPath, FileUtils.WORKSPACE_ROOT) && resolvedPath !== FileUtils.WORKSPACE_ROOT) {
+            throw new Error(`Access denied: Path is outside the workspace boundary`);
+        }
+
+        return resolvedPath;
+    }
+
+    /**
+     * Check if file exists
+     * @param {string} filePath - File path
+     * @returns {boolean} Whether file exists
+     */
+    static fileExists(filePath) {
+        const securePath = FileUtils.getSecurePath(filePath);
+        return existsSync(securePath);
+    }
+
+    /**
+     * Read file content
+     * @param {string} filePath - File path
+     * @returns {Promise<string>} File content
+     */
+    static async readFile(filePath) {
+        const securePath = FileUtils.getSecurePath(filePath);
+        if (!existsSync(securePath)) {
+            throw new Error(`File not found: ${securePath}`);
+        }
+        return await fs.readFile(securePath, 'utf8');
+    }
+
+    /**
+     * Write file content
+     * @param {string} filePath - File path
+     * @param {string} content - File content
+     */
+    static async writeFile(filePath, content) {
+        const securePath = FileUtils.getSecurePath(filePath);
+        const dir = dirname(securePath);
+
+        // Ensure directory exists
+        await fs.mkdir(dir, { recursive: true });
+        await fs.writeFile(securePath, content, 'utf8');
+    }
+
+    /**
+     * Create MCP standard response format
+     * @param {string} text - Response text
+     * @returns {Object} MCP response format
+     */
+    static createResponse(text) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: text
+                }
+            ]
+        };
+    }
+
+    /**
+     * Create MCP error response format
+     * @param {string} errorMessage - Error message
+     * @returns {Object} MCP error response format
+     */
+    static createErrorResponse(errorMessage) {
+        return {
+            isError: true,
+            content: [
+                {
+                    type: "text",
+                    text: `Error: ${errorMessage}`
+                }
+            ]
+        };
+    }
+
+    /**
+     * Count number of lines in a string
+     * @param {string} content - String content
+     * @returns {number} Number of lines
+     */
+    static countLines(content) {
+        return content.split('\n').length;
+    }
+
+    /**
+     * Get specified line range from file
+     * @param {string} content - File content
+     * @param {string} lineRange - Line range, e.g. "1-10"
+     * @returns {string} Content of specified range
+     */    static getLineRange(content, lineRange) {
+        // Validate line range format
+        if (!lineRange || !lineRange.includes('-')) {
+            throw new Error(`Invalid line range format: ${lineRange}. Expected format: 'start-end'`);
+        }
+
+        const [start, end] = lineRange.split('-').map(Number);
+
+        // Validate line numbers are valid numbers
+        if (isNaN(start) || isNaN(end)) {
+            throw new Error(`Invalid line range: ${lineRange}. Start and end must be valid numbers`);
+        }
+
+        // Validate line numbers are positive
+        if (start < 1 || end < 1) {
+            throw new Error(`Invalid line range: ${lineRange}. Line numbers must be positive`);
+        }
+
+        // Validate start line cannot be greater than end line
+        if (start > end) {
+            throw new Error(`Invalid line range: ${lineRange}. Start line cannot be greater than end line`);
+        }
+
+        const lines = content.split('\n');
+
+        // Validate line numbers do not exceed file range
+        if (start > lines.length) {
+            throw new Error(`Line range ${lineRange} exceeds file length (${lines.length} lines)`);
+        }
+
+        const selectedLines = lines.slice(start - 1, end);
+        return selectedLines.join('\n');
+    }
+
+    /**
+     * Format content with line numbers
+     * @param {string} content - Original content
+     * @param {number} startLine - Starting line number, default is 1
+     * @returns {string} Formatted content with line numbers
+     */
+    static formatWithLineNumbers(content, startLine = 1) {
+        const lines = content.split('\n');
+        const formattedLines = lines.map((line, index) => {
+            const lineNumber = startLine + index;
+            return `${lineNumber} | ${line}`;
+        });
+        return formattedLines.join('\n');
+    }
+}