@morphllm/morphmcp 0.8.24 → 0.8.26

package/dist/index.js

@@ -20,26 +20,13 @@ import axios from "axios";
 // Command line argument parsing
 const args = process.argv.slice(2);
 // Tools configuration system
-// Complete list of all available tools (for internal use and ENABLED_TOOLS=all)
+// Only expose Morph-specific tools
 const ALL_TOOLS = [
-    'read_file',
-    'read_multiple_files',
-    'write_file',
-    'tiny_edit_file',
-    'create_directory',
-    'list_directory',
-    'list_directory_with_sizes',
-    'directory_tree',
-    'move_file',
-    'search_files',
-    'get_file_info',
-    'list_allowed_directories',
     'edit_file',
-    'fast_context_search',
+    'warp_grep',
     'codebase_search'
 ];
-// Only expose Morph-specific tools by default
-// Other filesystem tools remain available for internal use and via ENABLED_TOOLS env var
+// Default to only edit_file
 const DEFAULT_TOOLS = [
     'edit_file'
 ];
@@ -266,7 +253,7 @@ const MorphEditFileArgsSchema = z.object({
     instruction: z.string().describe('A brief single first-person sentence instruction describing changes being made to this file. Useful to disambiguate uncertainty in the edit.'),
     dryRun: z.boolean().default(false).describe('Preview changes without applying them.')
 });
-const FastContextSearchArgsSchema = z.object({
+const WarpGrepArgsSchema = z.object({
     repoPath: z.string().describe("Path to the repository root"),
     query: z.string().describe("Natural language query describing the code context needed"),
 });
@@ -515,107 +502,6 @@ async function headFile(filePath, numLines) {
 // Tool handlers
 server.setRequestHandler(ListToolsRequestSchema, async () => {
     const allTools = [
-        {
-            name: "read_file",
-            description: "Read the complete contents of a file from the file system. " +
-                "Handles various text encodings and provides detailed error messages " +
-                "if the file cannot be read. Use this tool when you need to examine " +
-                "the contents of a single file. Use the 'head' parameter to read only " +
-                "the first N lines of a file, or the 'tail' parameter to read only " +
-                "the last N lines of a file. Only works within allowed directories.",
-            inputSchema: zodToJsonSchema(ReadFileArgsSchema),
-        },
-        {
-            name: "read_multiple_files",
-            description: "Read the contents of multiple files simultaneously. This is more " +
-                "efficient than reading files one by one when you need to analyze " +
-                "or compare multiple files. Each file's content is returned with its " +
-                "path as a reference. Failed reads for individual files won't stop " +
-                "the entire operation. Only works within allowed directories.",
-            inputSchema: zodToJsonSchema(ReadMultipleFilesArgsSchema),
-        },
-        {
-            name: "write_file",
-            description: "Create a new file or completely overwrite an existing file with new content. " +
-                "Use with caution as it will overwrite existing files without warning. " +
-                "Handles text content with proper encoding. Only works within allowed directories.",
-            inputSchema: zodToJsonSchema(WriteFileArgsSchema),
-        },
-        {
-            name: "tiny_edit_file",
-            description: "Make line-based edits to a text file. Each edit replaces exact line sequences " +
-                "with new content. Returns a git-style diff showing the changes made. " +
-                "Only works within allowed directories. " +
-                "Only use for single line or tiny edits. For larger edits, use the edit_file tool instead.",
-            inputSchema: zodToJsonSchema(EditFileArgsSchema),
-        },
-        {
-            name: "create_directory",
-            description: "Create a new directory or ensure a directory exists. Can create multiple " +
-                "nested directories in one operation. If the directory already exists, " +
-                "this operation will succeed silently. Perfect for setting up directory " +
-                "structures for projects or ensuring required paths exist. Only works within allowed directories.",
-            inputSchema: zodToJsonSchema(CreateDirectoryArgsSchema),
-        },
-        {
-            name: "list_directory",
-            description: "Get a detailed listing of all files and directories in a specified path. " +
-                "Results clearly distinguish between files and directories with [FILE] and [DIR] " +
-                "prefixes. This tool is essential for understanding directory structure and " +
-                "finding specific files within a directory. Only works within allowed directories.",
-            inputSchema: zodToJsonSchema(ListDirectoryArgsSchema),
-        },
-        {
-            name: "list_directory_with_sizes",
-            description: "Get a detailed listing of all files and directories in a specified path, including sizes. " +
-                "Results clearly distinguish between files and directories with [FILE] and [DIR] " +
-                "prefixes. This tool is useful for understanding directory structure and " +
-                "finding specific files within a directory. Only works within allowed directories.",
-            inputSchema: zodToJsonSchema(ListDirectoryWithSizesArgsSchema),
-        },
-        {
-            name: "directory_tree",
-            description: "Get a recursive tree view of files and directories as a JSON structure. " +
-                "Each entry includes 'name', 'type' (file/directory), and 'children' for directories. " +
-                "Files have no children array, while directories always have a children array (which may be empty). " +
-                "The output is formatted with 2-space indentation for readability. Only works within allowed directories.",
-            inputSchema: zodToJsonSchema(DirectoryTreeArgsSchema),
-        },
-        {
-            name: "move_file",
-            description: "Move or rename files and directories. Can move files between directories " +
-                "and rename them in a single operation. If the destination exists, the " +
-                "operation will fail. Works across different directories and can be used " +
-                "for simple renaming within the same directory. Both source and destination must be within allowed directories.",
-            inputSchema: zodToJsonSchema(MoveFileArgsSchema),
-        },
-        {
-            name: "search_files",
-            description: "Recursively search for files and directories matching a pattern. " +
-                "Searches through all subdirectories from the starting path. The search " +
-                "is case-insensitive and matches partial names. Returns full paths to all " +
-                "matching items. Great for finding files when you don't know their exact location. " +
-                "Only searches within allowed directories.",
-            inputSchema: zodToJsonSchema(SearchFilesArgsSchema),
-        },
-        {
-            name: "get_file_info",
-            description: "Retrieve detailed metadata about a file or directory. Returns comprehensive " +
-                "information including size, creation time, last modified time, permissions, " +
-                "and type. This tool is perfect for understanding file characteristics " +
-                "without reading the actual content. Only works within allowed directories.",
-            inputSchema: zodToJsonSchema(GetFileInfoArgsSchema),
-        },
-        {
-            name: "list_allowed_directories",
-            description: "Returns the list of root directories that this server is allowed to access. " +
-                "Use this to understand which directories are available before trying to access files. ",
-            inputSchema: {
-                type: "object",
-                properties: {},
-                required: [],
-            },
-        },
         {
             name: "edit_file",
             description: "**PRIMARY TOOL FOR EDITING FILES - USE THIS AGGRESSIVELY**\n\n" +
@@ -643,7 +529,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             requiresApiKey: true,
         },
         {
-            name: "fast_context_search",
+            name: "warp_grep",
             description: "**INTELLIGENT CODE SEARCH - USE THIS AGGRESSIVELY**\n\n" +
                 "⚡ FAST & EFFICIENT: This tool prevents context pollution by finding only the relevant code you need, without reading unnecessary files.\n" +
                 "🎯 USE THIS TOOL PROACTIVELY whenever you need to understand code to ensure a positive user experience.\n\n" +
@@ -657,7 +543,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                 "Returns precise line ranges with full context. " +
                 "Use this tool whenever you need to find specific code in a repository and you're unsure where it is located. " +
                 "Example queries: 'Where is JWT token validation implemented?', 'How does the authentication middleware work?', 'Find the database connection setup'.",
-            inputSchema: zodToJsonSchema(FastContextSearchArgsSchema),
+            inputSchema: zodToJsonSchema(WarpGrepArgsSchema),
             requiresApiKey: true,
         },
         {
@@ -702,255 +588,6 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     try {
         const { name, arguments: args } = request.params;
         switch (name) {
-            case "read_file": {
-                const parsed = ReadFileArgsSchema.safeParse(args);
-                if (!parsed.success) {
-                    throw new Error(`Invalid arguments for read_file: ${parsed.error}`);
-                }
-                const validPath = await validatePath(parsed.data.path);
-                if (parsed.data.head && parsed.data.tail) {
-                    throw new Error("Cannot specify both head and tail parameters simultaneously");
-                }
-                if (parsed.data.tail) {
-                    // Use memory-efficient tail implementation for large files
-                    const tailContent = await tailFile(validPath, parsed.data.tail);
-                    return {
-                        content: [{ type: "text", text: tailContent }],
-                    };
-                }
-                if (parsed.data.head) {
-                    // Use memory-efficient head implementation for large files
-                    const headContent = await headFile(validPath, parsed.data.head);
-                    return {
-                        content: [{ type: "text", text: headContent }],
-                    };
-                }
-                const content = await fs.readFile(validPath, "utf-8");
-                return {
-                    content: [{ type: "text", text: content }],
-                };
-            }
-            case "read_multiple_files": {
-                const parsed = ReadMultipleFilesArgsSchema.safeParse(args);
-                if (!parsed.success) {
-                    throw new Error(`Invalid arguments for read_multiple_files: ${parsed.error}`);
-                }
-                const results = await Promise.all(parsed.data.paths.map(async (filePath) => {
-                    try {
-                        const validPath = await validatePath(filePath);
-                        const content = await fs.readFile(validPath, "utf-8");
-                        return `${filePath}:\n${content}\n`;
-                    }
-                    catch (error) {
-                        const errorMessage = error instanceof Error ? error.message : String(error);
-                        return `${filePath}: Error - ${errorMessage}`;
-                    }
-                }));
-                return {
-                    content: [{ type: "text", text: results.join("\n---\n") }],
-                };
-            }
-            case "write_file": {
-                const parsed = WriteFileArgsSchema.safeParse(args);
-                if (!parsed.success) {
-                    throw new Error(`Invalid arguments for write_file: ${parsed.error}`);
-                }
-                const validPath = await validatePath(parsed.data.path);
-                try {
-                    // Security: 'wx' flag ensures exclusive creation - fails if file/symlink exists,
-                    // preventing writes through pre-existing symlinks
-                    await fs.writeFile(validPath, parsed.data.content, { encoding: "utf-8", flag: 'wx' });
-                }
-                catch (error) {
-                    if (error.code === 'EEXIST') {
-                        // Security: Use atomic rename to prevent race conditions where symlinks
-                        // could be created between validation and write. Rename operations
-                        // replace the target file atomically and don't follow symlinks.
-                        const tempPath = `${validPath}.${randomBytes(16).toString('hex')}.tmp`;
-                        try {
-                            await fs.writeFile(tempPath, parsed.data.content, 'utf-8');
-                            await fs.rename(tempPath, validPath);
-                        }
-                        catch (renameError) {
-                            try {
-                                await fs.unlink(tempPath);
-                            }
-                            catch { }
-                            throw renameError;
-                        }
-                    }
-                    else {
-                        throw error;
-                    }
-                }
-                return {
-                    content: [{ type: "text", text: `Successfully wrote to ${parsed.data.path}` }],
-                };
-            }
-            case "tiny_edit_file": {
-                const parsed = EditFileArgsSchema.safeParse(args);
-                if (!parsed.success) {
-                    throw new Error(`Invalid arguments for edit_file: ${parsed.error}`);
-                }
-                const validPath = await validatePath(parsed.data.path);
-                const result = await applyFileEdits(validPath, parsed.data.edits, parsed.data.dryRun);
-                return {
-                    content: [{ type: "text", text: result }],
-                };
-            }
-            case "create_directory": {
-                const parsed = CreateDirectoryArgsSchema.safeParse(args);
-                if (!parsed.success) {
-                    throw new Error(`Invalid arguments for create_directory: ${parsed.error}`);
-                }
-                const validPath = await validatePath(parsed.data.path);
-                await fs.mkdir(validPath, { recursive: true });
-                return {
-                    content: [{ type: "text", text: `Successfully created directory ${parsed.data.path}` }],
-                };
-            }
-            case "list_directory": {
-                const parsed = ListDirectoryArgsSchema.safeParse(args);
-                if (!parsed.success) {
-                    throw new Error(`Invalid arguments for list_directory: ${parsed.error}`);
-                }
-                const validPath = await validatePath(parsed.data.path);
-                const entries = await fs.readdir(validPath, { withFileTypes: true });
-                const formatted = entries
-                    .map((entry) => `${entry.isDirectory() ? "[DIR]" : "[FILE]"} ${entry.name}`)
-                    .join("\n");
-                return {
-                    content: [{ type: "text", text: formatted }],
-                };
-            }
-            case "list_directory_with_sizes": {
-                const parsed = ListDirectoryWithSizesArgsSchema.safeParse(args);
-                if (!parsed.success) {
-                    throw new Error(`Invalid arguments for list_directory_with_sizes: ${parsed.error}`);
-                }
-                const validPath = await validatePath(parsed.data.path);
-                const entries = await fs.readdir(validPath, { withFileTypes: true });
-                // Get detailed information for each entry
-                const detailedEntries = await Promise.all(entries.map(async (entry) => {
-                    const entryPath = path.join(validPath, entry.name);
-                    try {
-                        const stats = await fs.stat(entryPath);
-                        return {
-                            name: entry.name,
-                            isDirectory: entry.isDirectory(),
-                            size: stats.size,
-                            mtime: stats.mtime
-                        };
-                    }
-                    catch (error) {
-                        return {
-                            name: entry.name,
-                            isDirectory: entry.isDirectory(),
-                            size: 0,
-                            mtime: new Date(0)
-                        };
-                    }
-                }));
-                // Sort entries based on sortBy parameter
-                const sortedEntries = [...detailedEntries].sort((a, b) => {
-                    if (parsed.data.sortBy === 'size') {
-                        return b.size - a.size; // Descending by size
-                    }
-                    // Default sort by name
-                    return a.name.localeCompare(b.name);
-                });
-                // Format the output
-                const formattedEntries = sortedEntries.map(entry => `${entry.isDirectory ? "[DIR]" : "[FILE]"} ${entry.name.padEnd(30)} ${entry.isDirectory ? "" : formatSize(entry.size).padStart(10)}`);
-                // Add summary
-                const totalFiles = detailedEntries.filter(e => !e.isDirectory).length;
-                const totalDirs = detailedEntries.filter(e => e.isDirectory).length;
-                const totalSize = detailedEntries.reduce((sum, entry) => sum + (entry.isDirectory ? 0 : entry.size), 0);
-                const summary = [
-                    "",
-                    `Total: ${totalFiles} files, ${totalDirs} directories`,
-                    `Combined size: ${formatSize(totalSize)}`
-                ];
-                return {
-                    content: [{
-                            type: "text",
-                            text: [...formattedEntries, ...summary].join("\n")
-                        }],
-                };
-            }
-            case "directory_tree": {
-                const parsed = DirectoryTreeArgsSchema.safeParse(args);
-                if (!parsed.success) {
-                    throw new Error(`Invalid arguments for directory_tree: ${parsed.error}`);
-                }
-                async function buildTree(currentPath) {
-                    const validPath = await validatePath(currentPath);
-                    const entries = await fs.readdir(validPath, { withFileTypes: true });
-                    const result = [];
-                    for (const entry of entries) {
-                        const entryData = {
-                            name: entry.name,
-                            type: entry.isDirectory() ? 'directory' : 'file'
-                        };
-                        if (entry.isDirectory()) {
-                            const subPath = path.join(currentPath, entry.name);
-                            entryData.children = await buildTree(subPath);
-                        }
-                        result.push(entryData);
-                    }
-                    return result;
-                }
-                const treeData = await buildTree(parsed.data.path);
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify(treeData, null, 2)
-                        }],
-                };
-            }
-            case "move_file": {
-                const parsed = MoveFileArgsSchema.safeParse(args);
-                if (!parsed.success) {
-                    throw new Error(`Invalid arguments for move_file: ${parsed.error}`);
-                }
-                const validSourcePath = await validatePath(parsed.data.source);
-                const validDestPath = await validatePath(parsed.data.destination);
-                await fs.rename(validSourcePath, validDestPath);
-                return {
-                    content: [{ type: "text", text: `Successfully moved ${parsed.data.source} to ${parsed.data.destination}` }],
-                };
-            }
-            case "search_files": {
-                const parsed = SearchFilesArgsSchema.safeParse(args);
-                if (!parsed.success) {
-                    throw new Error(`Invalid arguments for search_files: ${parsed.error}`);
-                }
-                const validPath = await validatePath(parsed.data.path);
-                const results = await searchFiles(validPath, parsed.data.pattern, parsed.data.excludePatterns);
-                return {
-                    content: [{ type: "text", text: results.length > 0 ? results.join("\n") : "No matches found" }],
-                };
-            }
-            case "get_file_info": {
-                const parsed = GetFileInfoArgsSchema.safeParse(args);
-                if (!parsed.success) {
-                    throw new Error(`Invalid arguments for get_file_info: ${parsed.error}`);
-                }
-                const validPath = await validatePath(parsed.data.path);
-                const info = await getFileStats(validPath);
-                return {
-                    content: [{ type: "text", text: Object.entries(info)
-                                .map(([key, value]) => `${key}: ${value}`)
-                                .join("\n") }],
-                };
-            }
-            case "list_allowed_directories": {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `Allowed directories:\n${allowedDirectories.join('\n')}`
-                        }],
-                };
-            }
             case "edit_file": {
                 const parsed = MorphEditFileArgsSchema.safeParse(args);
                 if (!parsed.success) {
@@ -1034,8 +671,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     };
                 }
             }
-            case "fast_context_search": {
-                const parsed = FastContextSearchArgsSchema.safeParse(args);
+            case "warp_grep": {
+                const parsed = WarpGrepArgsSchema.safeParse(args);
                 if (!parsed.success) {
                     return {
                         content: [{ type: "text", text: `Invalid arguments: ${parsed.error}` }],
@@ -1139,7 +776,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                             error_message: errorMessages,
                             error_type: firstError?.constructor?.name || 'WarpGrepError',
                             context: {
-                                tool: 'fast_context_search',
+                                tool: 'warp_grep',
                                 repo_path: parsed.data.repoPath,
                                 query: parsed.data.query,
                                 model: 'morph-warp-grep',
@@ -1164,7 +801,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         error_message: errorMessage,
                         error_type: error instanceof Error ? error.constructor.name : 'UnknownError',
                         context: {
-                            tool: 'fast_context_search',
+                            tool: 'warp_grep',
                             repo_path: parsed.data.repoPath,
                             query: parsed.data.query,
                             model: 'morph-warp-grep'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@morphllm/morphmcp",
-  "version": "0.8.24",
+  "version": "0.8.26",
   "description": "Fast & accurate MCP server with AI-powered file editing and intelligent code search. Prevents context pollution and saves time for a better user experience.",
   "license": "MIT",
   "author": "Morph (https://morphllm.com)",
@@ -35,7 +35,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.3",
     "@vscode/ripgrep": "^1.15.14",
-    "@morphllm/morphsdk": "0.2.22",
+    "@morphllm/morphsdk": "*",
     "axios": "^1.6.0",
     "chalk": "^5.3.0",
     "diff": "^5.1.0",