@morphllm/morphmcp 0.8.18 → 0.8.23

package/README.md

@@ -1,13 +1,11 @@
 # Morph MCP
 
-Unified Model Context Protocol (MCP) server providing AI-powered file editing and intelligent code search capabilities. Built on Morph's SDK for fast, accurate code operations.
+Unified Model Context Protocol (MCP) server providing AI-powered file editing capabilities. Built on Morph's SDK for fast, accurate code operations.
 
 ## Features
 
 ### AI-Powered Tools
 - **Fast Apply (edit_file)** - Morph's lightning-fast code editing at 10,500+ tokens/sec with 98% accuracy
-- **Semantic Search (codebase_search)** - Natural language code search using embeddings and GPU reranking for finding relevant code across your codebase
-- **Fast Context Search (fast_context_search)** - AI-powered grep agent using WarpGrep that intelligently explores repositories to find relevant code
 
 ### Filesystem Operations
 - Read/write files with memory-efficient head/tail operations
@@ -30,36 +28,26 @@ Unified Model Context Protocol (MCP) server providing AI-powered file editing an
 | Variable | Description | Default |
 |----------|-------------|---------|
 | `MORPH_API_KEY` | Your Morph API key (required for AI tools) | - |
-| `ENABLED_TOOLS` | Comma-separated list of enabled tools, or `all` | `edit_file,codebase_search` |
-| `MORPH_DEBUG` | Enable debug logging for grep agent (`true`/`false`) | `false` |
+| `ENABLED_TOOLS` | Comma-separated list of enabled tools, or `all` | `edit_file` |
 | `ENABLE_WORKSPACE_MODE` | Auto-detect workspace root (`true`/`false`) | `true` |
 | `WORKSPACE_ROOT` | Override workspace root directory | `$PWD` |
 
 ### Tool Configuration
 
-Control which tools are available using `ENABLED_TOOLS`. **By default, only AI-powered tools (`edit_file` and `codebase_search`) are enabled** to keep the interface clean. Enable additional filesystem tools as needed:
+Control which tools are available using `ENABLED_TOOLS`. **By default, only the AI-powered tool (`edit_file`) is enabled** to keep the interface clean. Enable additional filesystem tools as needed:
 
 ```bash
-# Default: Only AI-powered tools
-# (No ENABLED_TOOLS needed - edit_file and codebase_search are enabled by default)
+# Default: Only AI-powered tool
+# (No ENABLED_TOOLS needed - edit_file is enabled by default)
 
 # Enable all tools including filesystem operations
 ENABLED_TOOLS=all
 
-# Only AI-powered tools (explicit, same as default)
-ENABLED_TOOLS=edit_file,codebase_search
-
-# Only fast apply
+# Only fast apply (explicit, same as default)
 ENABLED_TOOLS=edit_file
 
-# Only semantic search
-ENABLED_TOOLS=codebase_search
-
-# Include fast_context_search (grep agent)
-ENABLED_TOOLS=edit_file,codebase_search,fast_context_search
-
 # Custom selection
-ENABLED_TOOLS=read_file,write_file,edit_file,codebase_search
+ENABLED_TOOLS=read_file,write_file,edit_file
 ```
 
 ## Available Tools
@@ -81,78 +69,6 @@ ENABLED_TOOLS=read_file,write_file,edit_file,codebase_search
 
 **Note for Cursor users:** If you're using this tool within Cursor, you may need to first use another tool (like `search_replace`) to add exactly one empty newline somewhere in the file before using `edit_file`. This ensures the file is in an editable state.
 
-#### `codebase_search`
-**SEMANTIC CODE SEARCH** - Find code using natural language queries. Uses two-stage retrieval (vector search + GPU reranking) to find the most relevant code across your entire codebase.
-
-**Key features:**
-- Natural language queries: "Where is JWT validation?" or "How does auth work?"
-- Two-stage retrieval: Vector search (~240ms) + GPU reranking (~630ms)
-- Returns precise code chunks with relevance scores
-- Searches by semantic meaning, not just keywords
-- Works across all files and languages
-
-**Requires:** `MORPH_API_KEY` and code pushed to Morph git
-
-**How it works:**
-```
-┌─────────────────────────────────────────────────────────────┐
-│  SEMANTIC SEARCH LIFECYCLE                                  │
-└─────────────────────────────────────────────────────────────┘
-
-1. CODE CHANGES                    2. AUTO-SYNC (Plugin)
-   ┌─────────────┐                    ┌─────────────┐
-   │ Agent edits │ ────────────────── │ git commit  │
-   │   files     │                     │ + push      │
-   └─────────────┘                     └──────┬──────┘
-                                              │
-                                              ▼
-3. EMBEDDING (3-8s)                4. INDEXED & SEARCHABLE
-   ┌─────────────────┐                ┌──────────────────┐
-   │ Code chunking   │                │ PostgreSQL       │
-   │ morph-v4-embed  │ ────────────  │ pgvector (HNSW)  │
-   │ Vector storage  │                │ Ready for search │
-   └─────────────────┘                └────────┬─────────┘
-                                               │
-                                               ▼
-5. SEARCH QUERY                    6. TWO-STAGE RETRIEVAL
-   ┌─────────────────┐                ┌──────────────────┐
-   │ "Find auth      │                │ Vector: top 50   │
-   │  logic"         │ ────────────  │ Rerank: top 10   │
-   └─────────────────┘                │ ~1000ms total    │
-                                      └────────┬─────────┘
-                                               │
-                                               ▼
-7. RESULTS                         8. AGENT USES CONTEXT
-   ┌─────────────────┐                ┌──────────────────┐
-   │ Ranked code     │                │ Makes informed   │
-   │ with scores     │ ────────────  │ edits with       │
-   │ + line numbers  │                │ relevant context │
-   └─────────────────┘                └──────────────────┘
-```
-
-**Setup:** Install the `morph-sync` plugin to automatically sync code after every agent response. See [Enable Semantic Search](#enable-semantic-search-with-morph-sync-plugin) below.
-
-**Example queries:**
-- "Where is JWT validation implemented?"
-- "How does the authentication middleware work?"
-- "Find database connection setup"
-
-#### `fast_context_search`
-Intelligently search and gather relevant code context from a repository using Morph's WarpGrep AI-powered search agent. Automatically explores the codebase with grep, file reading, and directory analysis to find exactly what you need.
-
-**Key features:**
-- AI-powered multi-round exploration
-- Returns precise line ranges, not entire files
-- Prevents context pollution by finding only relevant code
-- Formatted XML output with line numbers
-
-**Example queries:**
-- "Where is JWT token validation implemented?"
-- "How does the authentication middleware work?"
-- "Find the database connection setup"
-
-**Requires:** `MORPH_API_KEY`
-
 ### File Operations
 *Note: These tools are available but disabled by default. Set `ENABLED_TOOLS=all` to enable.*
 
@@ -288,16 +204,6 @@ Or manually add to `.vscode/mcp.json`:
 }
 ```
 
-**For semantic code search only:**
-```json
-{
-  "env": {
-    "MORPH_API_KEY": "sk-...",
-    "ENABLED_TOOLS": "codebase_search"
-  }
-}
-```
-
 **For everything (including all filesystem tools):**
 ```json
 {
@@ -308,32 +214,20 @@ Or manually add to `.vscode/mcp.json`:
 }
 ```
 
-**Default (AI tools only - recommended for most use cases):**
+**Default (AI tool only - recommended for most use cases):**
 ```json
 {
   "env": {
     "MORPH_API_KEY": "sk-..."
-    // ENABLED_TOOLS defaults to edit_file,codebase_search
+    // ENABLED_TOOLS defaults to edit_file
   }
 }
 ```
 
-### 3. Enable Semantic Search (Optional but Recommended)
-
-For the `codebase_search` tool to work, code must be synced to Morph git. Install the `morph-sync` plugin:
-
-**In Claude Code:**
-```bash
-/plugin install morph-sync
-```
-
-The plugin automatically commits and pushes code after every agent response, triggering embedding in the background (3-8 seconds).
-
-### 4. Test Your Setup
+### 3. Test Your Setup
 
 In your AI assistant, try:
 - **Edit test:** "Use the edit_file tool to add a comment to the main function"
-- **Search test:** "Find the authentication logic in this codebase" (uses codebase_search)
 
 ## Usage Examples
 
@@ -350,35 +244,6 @@ The AI will:
 5. Report errors (if any) to Morph for continuous improvement
 ```
 
-### Semantic Code Search
-
-```
-Ask AI: "Find the authentication logic in this codebase"
-
-The codebase_search tool will:
-1. Query the embedded codebase using natural language
-2. Vector search retrieves top 50 candidates (~240ms)
-3. GPU reranking scores for precision (~630ms)
-4. Return top 10 most relevant code chunks with scores
-5. Include file paths, line numbers, and relevance percentages
-6. Agent uses this context to make informed edits
-
-Note: Requires code to be synced via morph-sync plugin
-```
-
-### Fast Context Search
-
-```
-Ask AI: "Use fast_context_search to find where JWT tokens are validated"
-
-The WarpGrep agent will:
-1. Explore the repository using grep, read, and analyse tools
-2. Perform multi-round intelligent exploration
-3. Find relevant code across multiple files
-4. Return precise line ranges with full context (not entire files)
-5. Display formatted XML output with line numbers
-6. Show summary of tool calls made during search
-```
 
 ## Migration Guide
 
@@ -404,26 +269,6 @@ The WarpGrep agent will:
 }
 ```
 
-### From `morph-codeseek`
-
-**Old config:**
-```json
-{
-  "env": {
-    "GREP_AGENT_API_KEY": "sk-..."
-  }
-}
-```
-
-**New config:**
-```json
-{
-  "env": {
-    "MORPH_API_KEY": "sk-...",
-    "ENABLED_TOOLS": "fast_context_search"
-  }
-}
-```
 
 ## Architecture
 
@@ -432,19 +277,15 @@ The WarpGrep agent will:
 ```
 morph-mcp/
 ├── index.ts              # Main server & tool registry
-├── grep/                 # Fast context search agent (WarpGrep)
-│   ├── agent/           # Multi-round exploration logic
-│   ├── tools/           # Grep, read, analyse, finish
-│   └── utils/           # Ripgrep, file finder, logger
 ├── path-utils.ts        # Path normalization & Windows/WSL support
 ├── path-validation.ts   # Security validation
 ├── roots-utils.ts       # MCP Roots protocol handling
-└── @morphllm/morphsdk   # Morph SDK integration (Fast Apply & WarpGrep)
+└── @morphllm/morphsdk   # Morph SDK integration (Fast Apply)
 ```
 
 ### Dependencies
 
-- **@morphllm/morphsdk** (v0.2.22) - Core Fast Apply and WarpGrep functionality
+- **@morphllm/morphsdk** (v0.2.22) - Core Fast Apply functionality
 - **@modelcontextprotocol/sdk** (v1.12.3) - MCP protocol implementation
 - **@vscode/ripgrep** - Fast text search engine
 
@@ -463,19 +304,11 @@ morph-mcp/
 ### Tools Not Showing Up
 
 1. Check API key is set: `MORPH_API_KEY=sk-...`
-2. **By default, only `edit_file` and `fast_context_search` are enabled.** To enable all filesystem tools, set `ENABLED_TOOLS=all`
+2. **By default, only `edit_file` is enabled.** To enable all filesystem tools, set `ENABLED_TOOLS=all`
 3. Verify the tool name is in your `ENABLED_TOOLS` list
 4. Restart your AI assistant completely
 5. Check logs: `tail -f ~/Library/Logs/Claude/mcp*.log` (Claude Desktop) or check stderr output
 
-### Fast Context Search Not Finding Code
-
-1. Ensure you're passing the correct repository path (absolute or relative to workspace)
-2. Try more specific queries - WarpGrep works best with clear, descriptive queries
-3. Enable debug logging: `MORPH_DEBUG=true`
-4. Check that `MORPH_API_KEY` is correctly set
-5. Verify the repository path is within allowed directories (use `list_allowed_directories` tool)
-
 ### Permission Errors
 
 1. Check allowed directories: Use `list_allowed_directories` tool
@@ -487,7 +320,6 @@ morph-mcp/
 | Feature | Speed | Accuracy |
 |---------|-------|----------|
 | Fast Apply (edit_file) | 10,500+ tok/sec | 98% |
-| Context Search (WarpGrep) | Multi-round, 30s | High relevance |
 | File Operations | Native speed | 100% |
 
 **Note:** Performance metrics are based on Morph's production models. Actual performance may vary based on file size, complexity, and network conditions.

package/dist/index.js

@@ -8,11 +8,12 @@ import os from 'os';
 import { randomBytes } from 'crypto';
 import { z } from "zod";
 import { zodToJsonSchema } from "zod-to-json-schema";
-import { createTwoFilesPatch } from 'diff';
+import { createTwoFilesPatch } from './node_modules/@types/diff/index.js';
 import { minimatch } from 'minimatch';
 import { isPathWithinAllowedDirectories } from './path-validation.js';
 import { getValidRootDirectories } from './roots-utils.js';
 import { executeEditFile } from '@morphllm/morphsdk/tools/fastapply';
+import { runWarpGrep, LocalRipgrepProvider } from '@morphllm/morphsdk/tools/warp-grep';
 import { CodebaseSearchClient } from '@morphllm/morphsdk/tools/codebase-search';
 import axios from "axios";
 // Command line argument parsing
@@ -33,7 +34,7 @@ const ALL_TOOLS = [
     'get_file_info',
     'list_allowed_directories',
     'edit_file',
-    // 'fast_context_search', // Commented out - warp grep tool
+    'fast_context_search',
     'codebase_search'
 ];
 // Only expose Morph-specific tools by default
@@ -641,26 +642,24 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             inputSchema: zodToJsonSchema(MorphEditFileArgsSchema),
             requiresApiKey: true,
         },
-        // Commented out - warp grep tool
-        // {
-        //   name: "fast_context_search",
-        //   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" +
-        //     "Benefits:\n" +
-        //     "- Extremely fast: AI-powered search agent finds code in seconds\n" +
-        //     "- Prevents context pollution: Returns only relevant line ranges, not entire files\n" +
-        //     "- Intelligent exploration: Automatically greps, reads, and analyzes to find what you need\n" +
-        //     "- Precise results: Returns exact line numbers with full context\n\n" +
-        //     "Intelligently search and gather relevant code context from a repository using an AI-powered search agent. " +
-        //     "This tool automatically explores the codebase with grep, file reading, and directory analysis to find exactly the code snippets needed to answer questions about implementation details, architecture, or specific functionality. " +
-        //     "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) as ToolInput,
-        //   requiresApiKey: true,
-        // },
+        {
+            name: "fast_context_search",
+            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" +
+                "Benefits:\n" +
+                "- Extremely fast: AI-powered search agent finds code in seconds\n" +
+                "- Prevents context pollution: Returns only relevant line ranges, not entire files\n" +
+                "- Intelligent exploration: Automatically greps, reads, and analyzes to find what you need\n" +
+                "- Precise results: Returns exact line numbers with full context\n\n" +
+                "Intelligently search and gather relevant code context from a repository using an AI-powered search agent. " +
+                "This tool automatically explores the codebase with grep, file reading, and directory analysis to find exactly the code snippets needed to answer questions about implementation details, architecture, or specific functionality. " +
+                "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),
+            requiresApiKey: true,
+        },
         {
             name: "codebase_search",
             description: "**SEMANTIC CODE SEARCH - USE FOR FINDING CODE**\n\n" +
@@ -1035,157 +1034,150 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     };
                 }
             }
-            // Commented out - warp grep tool
-            // case "fast_context_search": {
-            //   const parsed = FastContextSearchArgsSchema.safeParse(args);
-            //   if (!parsed.success) {
-            //     return {
-            //       content: [{ type: "text", text: `Invalid arguments: ${parsed.error}` }],
-            //       isError: true,
-            //     };
-            //   }
-            //   try {
-            //     const repoRoot = path.resolve(parsed.data.repoPath);
-            //     const provider = new LocalRipgrepProvider(repoRoot);
-            //     const result = await runWarpGrep({
-            //       query: parsed.data.query,
-            //       repoRoot,
-            //       model: "morph-warp-grep",
-            //       apiKey: MORPH_API_KEY,
-            //       provider,
-            //     });
-            //     // Format response with tool calls summary, file list, and XML content
-            //     let responseText = "";
-            //     if (
-            //       result.terminationReason === "completed" &&
-            //       result.finish?.metadata?.files
-            //     ) {
-            //       const files = result.finish.metadata.files as Array<{
-            //         path: string;
-            //         lines: Array<[number, number]>;
-            //       }>;
-            //       // Build complete response
-            //       const parts: string[] = [];
-            //       // 1. Tool calls summary
-            //       const toolCallLines: string[] = [
-            //         "Morph Fast Context subagent performed search on repository:",
-            //       ];
-            //       for (const msg of result.messages) {
-            //         const role = msg.role as string;
-            //         const content = msg.content as string;
-            //         if (role === "assistant" && content) {
-            //           const toolLines = content.split("\n").filter((line: string) => line.trim());
-            //           for (const line of toolLines) {
-            //             const grepMatch = line.match(/^grep\s+'([^']+)'\s+(.+)$/);
-            //             if (grepMatch) {
-            //               toolCallLines.push(`- Grepped '${grepMatch[1]}' in \`${grepMatch[2]}\``);
-            //               continue;
-            //             }
-            //             const readMatch = line.match(/^read\s+(.+)$/);
-            //             if (readMatch) {
-            //               toolCallLines.push(`- Read file \`${readMatch[1]}\``);
-            //               continue;
-            //             }
-            //             const analyseMatch = line.match(/^analyse\s+(.+)$/);
-            //             if (analyseMatch) {
-            //               toolCallLines.push(`- Analysed directory \`${analyseMatch[1]}\``);
-            //               continue;
-            //             }
-            //           }
-            //         }
-            //       }
-            //       parts.push(toolCallLines.join("\n"));
-            //       // 2. List of files found
-            //       const fileListLines: string[] = ["", "Relevant context found:"];
-            //       for (const file of files) {
-            //         const rangeStrs = file.lines.map(([start, end]) => {
-            //           if (start === end) return `${start}`;
-            //           return `${start}-${end}`;
-            //         });
-            //         fileListLines.push(`- ${file.path}:${rangeStrs.join(",")}`);
-            //       }
-            //       fileListLines.push("");
-            //       parts.push(fileListLines.join("\n"));
-            //       // 3. Header for content section
-            //       parts.push("Here is the content of files:\n");
-            //       // 4. XML formatted file contents
-            //       const xmlBlocks: string[] = [];
-            //       for (const file of files) {
-            //         const filePath = path.resolve(parsed.data.repoPath, file.path);
-            //         try {
-            //           const content = await fs.readFile(filePath, { encoding: "utf-8" });
-            //           const lines = content.split(/\r?\n/);
-            //           const fileLines: string[] = [`<file path="${file.path}">`];
-            //           for (const [start, end] of file.lines) {
-            //             if (fileLines.length > 1) {
-            //               fileLines.push("");
-            //             }
-            //             for (let i = start; i <= end && i <= lines.length; i++) {
-            //               const lineContent = lines[i - 1];
-            //               fileLines.push(`${i}| ${lineContent}`);
-            //             }
-            //           }
-            //           fileLines.push("</file>");
-            //           xmlBlocks.push(fileLines.join("\n"));
-            //         } catch (error) {
-            //           xmlBlocks.push(
-            //             `<file path="${file.path}">\nError reading file: ${
-            //               error instanceof Error ? error.message : String(error)
-            //             }\n</file>`
-            //           );
-            //         }
-            //       }
-            //       parts.push(xmlBlocks.join("\n\n"));
-            //       responseText = parts.join("\n");
-            //     } else if (
-            //       result.terminationReason === "terminated" &&
-            //       result.errors.length > 0
-            //     ) {
-            //       const errorMessages = result.errors.map((e: any) => e.message).join("; ");
-            //       responseText = `Error: ${errorMessages}`;
-            //       // Report errors from WarpGrep agent
-            //       const firstError = result.errors[0];
-            //       reportMorphError({
-            //         error_message: errorMessages,
-            //         error_type: firstError?.constructor?.name || 'WarpGrepError',
-            //         context: {
-            //           tool: 'fast_context_search',
-            //           repo_path: parsed.data.repoPath,
-            //           query: parsed.data.query,
-            //           model: 'morph-warp-grep',
-            //           termination_reason: result.terminationReason,
-            //           error_count: result.errors.length
-            //         },
-            //         stack_trace: firstError?.stack || undefined,
-            //         source: 'mcp-filesystem'
-            //       }).catch(() => {}); // Silently ignore reporting failures
-            //     } else {
-            //       responseText = `Agent completed but did not call finish tool.`;
-            //     }
-            //     return {
-            //       content: [{ type: "text", text: responseText }],
-            //     };
-            //   } catch (error) {
-            //     const errorMessage = error instanceof Error ? error.message : String(error);
-            //     // Report error to Morph API (fire-and-forget)
-            //     reportMorphError({
-            //       error_message: errorMessage,
-            //       error_type: error instanceof Error ? error.constructor.name : 'UnknownError',
-            //       context: {
-            //         tool: 'fast_context_search',
-            //         repo_path: parsed.data.repoPath,
-            //         query: parsed.data.query,
-            //         model: 'morph-warp-grep'
-            //       },
-            //       stack_trace: error instanceof Error ? error.stack : undefined,
-            //       source: 'mcp-filesystem'
-            //     }).catch(() => {}); // Silently ignore reporting failures
-            //     return {
-            //       content: [{ type: "text", text: `Error running fast context search: ${errorMessage}` }],
-            //       isError: true,
-            //     };
-            //   }
-            // }
+            case "fast_context_search": {
+                const parsed = FastContextSearchArgsSchema.safeParse(args);
+                if (!parsed.success) {
+                    return {
+                        content: [{ type: "text", text: `Invalid arguments: ${parsed.error}` }],
+                        isError: true,
+                    };
+                }
+                try {
+                    const repoRoot = path.resolve(parsed.data.repoPath);
+                    const provider = new LocalRipgrepProvider(repoRoot);
+                    const result = await runWarpGrep({
+                        query: parsed.data.query,
+                        repoRoot,
+                        model: "morph-warp-grep",
+                        apiKey: MORPH_API_KEY,
+                        provider,
+                    });
+                    // Format response with tool calls summary, file list, and XML content
+                    let responseText = "";
+                    if (result.terminationReason === "completed" &&
+                        result.finish?.metadata?.files) {
+                        const files = result.finish.metadata.files;
+                        // Build complete response
+                        const parts = [];
+                        // 1. Tool calls summary
+                        const toolCallLines = [
+                            "Morph Fast Context subagent performed search on repository:",
+                        ];
+                        for (const msg of result.messages) {
+                            const role = msg.role;
+                            const content = msg.content;
+                            if (role === "assistant" && content) {
+                                const toolLines = content.split("\n").filter((line) => line.trim());
+                                for (const line of toolLines) {
+                                    const grepMatch = line.match(/^grep\s+'([^']+)'\s+(.+)$/);
+                                    if (grepMatch) {
+                                        toolCallLines.push(`- Grepped '${grepMatch[1]}' in \`${grepMatch[2]}\``);
+                                        continue;
+                                    }
+                                    const readMatch = line.match(/^read\s+(.+)$/);
+                                    if (readMatch) {
+                                        toolCallLines.push(`- Read file \`${readMatch[1]}\``);
+                                        continue;
+                                    }
+                                    const analyseMatch = line.match(/^analyse\s+(.+)$/);
+                                    if (analyseMatch) {
+                                        toolCallLines.push(`- Analysed directory \`${analyseMatch[1]}\``);
+                                        continue;
+                                    }
+                                }
+                            }
+                        }
+                        parts.push(toolCallLines.join("\n"));
+                        // 2. List of files found
+                        const fileListLines = ["", "Relevant context found:"];
+                        for (const file of files) {
+                            const rangeStrs = file.lines.map(([start, end]) => {
+                                if (start === end)
+                                    return `${start}`;
+                                return `${start}-${end}`;
+                            });
+                            fileListLines.push(`- ${file.path}:${rangeStrs.join(",")}`);
+                        }
+                        fileListLines.push("");
+                        parts.push(fileListLines.join("\n"));
+                        // 3. Header for content section
+                        parts.push("Here is the content of files:\n");
+                        // 4. XML formatted file contents
+                        const xmlBlocks = [];
+                        for (const file of files) {
+                            const filePath = path.resolve(parsed.data.repoPath, file.path);
+                            try {
+                                const content = await fs.readFile(filePath, { encoding: "utf-8" });
+                                const lines = content.split(/\r?\n/);
+                                const fileLines = [`<file path="${file.path}">`];
+                                for (const [start, end] of file.lines) {
+                                    if (fileLines.length > 1) {
+                                        fileLines.push("");
+                                    }
+                                    for (let i = start; i <= end && i <= lines.length; i++) {
+                                        const lineContent = lines[i - 1];
+                                        fileLines.push(`${i}| ${lineContent}`);
+                                    }
+                                }
+                                fileLines.push("</file>");
+                                xmlBlocks.push(fileLines.join("\n"));
+                            }
+                            catch (error) {
+                                xmlBlocks.push(`<file path="${file.path}">\nError reading file: ${error instanceof Error ? error.message : String(error)}\n</file>`);
+                            }
+                        }
+                        parts.push(xmlBlocks.join("\n\n"));
+                        responseText = parts.join("\n");
+                    }
+                    else if (result.terminationReason === "terminated" &&
+                        result.errors.length > 0) {
+                        const errorMessages = result.errors.map((e) => e.message).join("; ");
+                        responseText = `Error: ${errorMessages}`;
+                        // Report errors from WarpGrep agent
+                        const firstError = result.errors[0];
+                        reportMorphError({
+                            error_message: errorMessages,
+                            error_type: firstError?.constructor?.name || 'WarpGrepError',
+                            context: {
+                                tool: 'fast_context_search',
+                                repo_path: parsed.data.repoPath,
+                                query: parsed.data.query,
+                                model: 'morph-warp-grep',
+                                termination_reason: result.terminationReason,
+                                error_count: result.errors.length
+                            },
+                            stack_trace: firstError?.stack || undefined,
+                            source: 'mcp-filesystem'
+                        }).catch(() => { }); // Silently ignore reporting failures
+                    }
+                    else {
+                        responseText = `Agent completed but did not call finish tool.`;
+                    }
+                    return {
+                        content: [{ type: "text", text: responseText }],
+                    };
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    // Report error to Morph API (fire-and-forget)
+                    reportMorphError({
+                        error_message: errorMessage,
+                        error_type: error instanceof Error ? error.constructor.name : 'UnknownError',
+                        context: {
+                            tool: 'fast_context_search',
+                            repo_path: parsed.data.repoPath,
+                            query: parsed.data.query,
+                            model: 'morph-warp-grep'
+                        },
+                        stack_trace: error instanceof Error ? error.stack : undefined,
+                        source: 'mcp-filesystem'
+                    }).catch(() => { }); // Silently ignore reporting failures
+                    return {
+                        content: [{ type: "text", text: `Error running fast context search: ${errorMessage}` }],
+                        isError: true,
+                    };
+                }
+            }
             case "codebase_search": {
                 const parsed = CodebaseSearchArgsSchema.safeParse(args);
                 if (!parsed.success) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@morphllm/morphmcp",
-  "version": "0.8.18",
+  "version": "0.8.23",
   "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)",

package/dist/morph-client.d.ts

@@ -1,56 +0,0 @@
-declare const DEFAULT_MODEL = "morph-v3-large";
-declare const FAST_MODEL = "morph-v3-fast";
-export interface MorphResponse {
-    choices: Array<{
-        message: {
-            content: string;
-        };
-    }>;
-}
-export interface MorphEditOptions {
-    model?: string;
-    timeout?: number;
-    instruction?: string;
-    retries?: number;
-    retryDelay?: number;
-}
-export declare class MorphClient {
-    private apiKey;
-    private baseUrl;
-    private static errorReportUrl;
-    constructor(apiKey: string);
-    /**
-     * Apply code edit using Morph's AI models
-     * @param originalCode The original code content
-     * @param updateSnippet The update instructions or new code snippet
-     * @param options Configuration options
-     * @returns The updated code with changes applied
-     */
-    applyEdit(originalCode: string, updateSnippet: string, options?: MorphEditOptions): Promise<string>;
-    /**
-     * Report an error to Morph's error tracking system
-     * Fire-and-forget pattern - does not throw or block on failure
-     * @param errorDetails Error information to report
-     */
-    static reportError(errorDetails: {
-        error_message: string;
-        error_type?: string;
-        context?: Record<string, any>;
-        stack_trace?: string;
-        source?: string;
-    }): Promise<void>;
-    /**
-     * Validate API key format and test connectivity
-     * @returns Promise resolving to validation result
-     */
-    validateApiKey(): Promise<{
-        valid: boolean;
-        message: string;
-    }>;
-}
-/**
- * Get information about available Morph models
- * @returns Model information string
- */
-export declare function getMorphModelInfo(): string;
-export { DEFAULT_MODEL, FAST_MODEL };

package/dist/morph-client.js

@@ -1,160 +0,0 @@
-import axios from 'axios';
-// Constants
-const MORPH_API_BASE = "https://api.morphllm.com/v1";
-const DEFAULT_MODEL = "morph-v3-large"; // High accuracy model
-const FAST_MODEL = "morph-v3-fast"; // Speed-optimized model
-export class MorphClient {
-    apiKey;
-    baseUrl;
-    static errorReportUrl = "https://morphllm.com/api/error-report";
-    constructor(apiKey) {
-        this.apiKey = apiKey;
-        this.baseUrl = MORPH_API_BASE;
-    }
-    /**
-     * Apply code edit using Morph's AI models
-     * @param originalCode The original code content
-     * @param updateSnippet The update instructions or new code snippet
-     * @param options Configuration options
-     * @returns The updated code with changes applied
-     */
-    async applyEdit(originalCode, updateSnippet, options = {}) {
-        const { model = DEFAULT_MODEL, timeout = 30000, instruction, retries = 2, retryDelay = 1000 } = options;
-        const headers = {
-            "Authorization": `Bearer ${this.apiKey}`,
-            "Content-Type": "application/json",
-        };
-        const content = instruction
-            ? `<instruction>${instruction}</instruction>\n<code>${originalCode}</code>\n<update>${updateSnippet}</update>`
-            : `<code>${originalCode}</code>\n<update>${updateSnippet}</update>`;
-        const payload = {
-            model,
-            messages: [
-                {
-                    role: "user",
-                    content,
-                },
-            ],
-        };
-        let lastError;
-        for (let attempt = 0; attempt <= retries; attempt++) {
-            try {
-                const response = await axios.post(`${this.baseUrl}/chat/completions`, payload, {
-                    headers,
-                    timeout,
-                });
-                return response.data.choices[0].message.content.trim();
-            }
-            catch (error) {
-                lastError = error;
-                // Don't retry on authentication or client errors (4xx)
-                if (error.response && error.response.status >= 400 && error.response.status < 500) {
-                    throw new Error(`Morph API error ${error.response.status}: ${error.response.data?.error?.message || error.response.statusText}`);
-                }
-                // If we have more retries, wait and try again
-                if (attempt < retries) {
-                    const delay = retryDelay * Math.pow(2, attempt); // Exponential backoff
-                    console.error(`Morph API request failed (attempt ${attempt + 1}/${retries + 1}), retrying in ${delay}ms...`);
-                    await new Promise(resolve => setTimeout(resolve, delay));
-                    continue;
-                }
-            }
-        }
-        // All retries exhausted
-        if (lastError.response) {
-            throw new Error(`Morph API error ${lastError.response.status}: ${lastError.response.data?.error?.message || lastError.response.statusText}`);
-        }
-        else if (lastError.request) {
-            // Network error - no response received
-            const errorDetails = [];
-            if (lastError.code)
-                errorDetails.push(`Code: ${lastError.code}`);
-            if (lastError.message)
-                errorDetails.push(`Message: ${lastError.message}`);
-            const detailsStr = errorDetails.length > 0 ? ` (${errorDetails.join(', ')})` : '';
-            throw new Error(`Failed to connect to Morph API at ${this.baseUrl}${detailsStr}. ` +
-                `This may be due to network issues, firewall/proxy settings, or DNS problems. ` +
-                `Please check your internet connection and try again. (Failed after ${retries + 1} attempts)`);
-        }
-        throw new Error(`Unexpected error: ${lastError instanceof Error ? lastError.message : String(lastError)}`);
-    }
-    /**
-     * Report an error to Morph's error tracking system
-     * Fire-and-forget pattern - does not throw or block on failure
-     * @param errorDetails Error information to report
-     */
-    static async reportError(errorDetails) {
-        try {
-            await axios.post(MorphClient.errorReportUrl, {
-                ...errorDetails,
-                timestamp: new Date().toISOString(),
-                source: errorDetails.source || 'mcp-filesystem'
-            }, {
-                timeout: 5000, // Quick timeout for fire-and-forget
-                headers: {
-                    'Content-Type': 'application/json'
-                }
-            });
-        }
-        catch (error) {
-            // Silent failure - log to console but don't propagate
-            console.error('Failed to report error to Morph:', error instanceof Error ? error.message : String(error));
-        }
-    }
-    /**
-     * Validate API key format and test connectivity
-     * @returns Promise resolving to validation result
-     */
-    async validateApiKey() {
-        if (!this.apiKey) {
-            return { valid: false, message: "API key is required" };
-        }
-        if (!this.apiKey.startsWith('sk-') && !this.apiKey.startsWith('morph-')) {
-            return {
-                valid: false,
-                message: "API key format may be incorrect. Morph API keys typically start with 'sk-' or 'morph-'"
-            };
-        }
-        try {
-            // Test with a simple request
-            const result = await this.applyEdit("def test(): pass", "def test(): pass", { model: FAST_MODEL });
-            if (result && !result.includes("Error")) {
-                return {
-                    valid: true,
-                    message: `API key validated successfully (starts with: ${this.apiKey.substring(0, 10)}...)`
-                };
-            }
-            else {
-                return { valid: false, message: "API key validation failed" };
-            }
-        }
-        catch (error) {
-            return {
-                valid: false,
-                message: `API key validation failed: ${error instanceof Error ? error.message : String(error)}`
-            };
-        }
-    }
-}
-/**
- * Get information about available Morph models
- * @returns Model information string
- */
-export function getMorphModelInfo() {
-    return `
-Morph Apply API Models:
-
-1. morph-v3-large:
-   - Speed: 2500+ tokens/sec
-   - Accuracy: 98%
-   - Best for: High-accuracy code edits, complex transformations
-
-2. morph-v3-fast:
-   - Speed: 10,500+ tokens/sec  
-   - Accuracy: 96%
-   - Best for: Quick edits, simple transformations
-
-The 'useFastModel' parameter in tools controls whether to use morph-v3-fast (true) or morph-v3-large (false).
-  `.trim();
-}
-export { DEFAULT_MODEL, FAST_MODEL };