fileditor-mcp 1.0.2 → 1.0.3

package/src/handlers/setWorkspace.js

@@ -1,26 +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}`);
-        }
-    }
-}
+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

@@ -1,92 +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 {
-            // Use FileUtils to normalize parameters
-            const { paths, contents, lineCounts, fileCount } = FileUtils.normalizeMultiFileArgs(args);
-
-            const results = [];
-            const writeOperations = [];
-            const warnings = [];
-
-            // Perform all write operations
-            for (let i = 0; i < fileCount; i++) {
-                const filePath = paths[i];
-                const fileContent = contents[i];
-                const expectedLines = lineCounts[i];
-
-                // Execute write operations in parallel
-                writeOperations.push(
-                    FileUtils.writeFile(filePath, fileContent).then(() => {
-                        // Validate line count
-                        const actualLines = FileUtils.countLines(fileContent);
-                        if (expectedLines !== null && actualLines !== expectedLines) {
-                            warnings.push(`${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');
-            }
-
-            // Add warnings to the message if any
-            if (warnings.length > 0) {
-                message += '\n\nWarnings:\n' + warnings.map(w => `  ⚠️  ${w}`).join('\n');
-            }
-
-            return FileUtils.createResponse(message);
-
-        } catch (error) {
-            throw new Error(`Failed to write file(s): ${error.message}`);
-        }
-    }
+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

@@ -1,22 +1,22 @@
-#!/usr/bin/env node
-
-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();
+#!/usr/bin/env node
+
+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

@@ -1,85 +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");
-    }
-}
+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");
+    }
+}