added search, rename, replace tools to MCP server

Author: ndbroadbent

docs/src/content/docs/mcp/overview.mdx

@@ -81,15 +81,18 @@ Every renaming operation includes multiple safety layers:
 
 ## Available Tools
 
-The MCP Server provides 7 specialized tools:
+The MCP Server provides 10 specialized tools:
 
+- [**renamify_search**](/renamify/mcp/tools#renamify_search) - Search for identifiers across your codebase
 - [**renamify_plan**](/renamify/mcp/tools#renamify_plan) - Create a renaming plan with case-aware transformations
 - [**renamify_apply**](/renamify/mcp/tools#renamify_apply) - Execute a plan to make the actual changes
 - [**renamify_undo**](/renamify/mcp/tools#renamify_undo) - Revert a previously applied renaming
 - [**renamify_redo**](/renamify/mcp/tools#renamify_redo) - Re-apply an undone renaming
 - [**renamify_history**](/renamify/mcp/tools#renamify_history) - View past renaming operations
 - [**renamify_status**](/renamify/mcp/tools#renamify_status) - Check current state and pending plans
 - [**renamify_preview**](/renamify/mcp/tools#renamify_preview) - Review a plan in different formats
+- [**renamify_rename**](/renamify/mcp/tools#renamify_rename) - Case-aware rename (plan + apply in one step)
+- [**renamify_replace**](/renamify/mcp/tools#renamify_replace) - Simple regex/literal replacement without case transformations
 
 ## Installation Steps
 

docs/src/content/docs/mcp/tools.mdx

@@ -5,7 +5,7 @@ description: Complete reference for all Renamify MCP Server tools
 
 import { Card, CardGrid, Code } from '@astrojs/starlight/components';
 
-The Renamify MCP Server provides 7 specialized tools for AI agents to perform intelligent renaming operations.
+The Renamify MCP Server provides 10 specialized tools for AI agents to perform intelligent renaming operations.
 
 ## renamify_plan
 
@@ -312,6 +312,85 @@ Arguments: {
 +export function CustomerAccountComponent({ account }: CustomerAccountProps) {
 ```
 
+## renamify_rename
+
+Perform case-aware renaming in a single step (combines plan + apply).
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `old` | string | ✅ Yes | - | The identifier to replace |
+| `new` | string | ✅ Yes | - | The new identifier |
+| `paths` | string[] | No | Current dir | Paths to search |
+| `dryRun` | boolean | No | `false` | Preview without applying |
+| `preview` | string | No | `summary` | Preview format |
+| `excludeStyles` | string[] | No | None | Case styles to exclude |
+| `includeStyles` | string[] | No | None | Additional case styles |
+| `onlyStyles` | string[] | No | None | Use only these styles |
+
+### Example Usage
+
+```
+Tool: renamify_rename
+Arguments: {
+  "old": "getUserInfo",
+  "new": "fetchUserProfile",
+  "paths": ["src"],
+  "dryRun": true
+}
+```
+
+### When to Use
+
+- Quick renames without saving a plan
+- Simple refactorings with immediate apply
+- When you don't need to review changes beforehand
+
+## renamify_replace
+
+Perform simple regex or literal string replacement without case transformations.
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `pattern` | string | ✅ Yes | - | Search pattern (regex or literal) |
+| `replacement` | string | ✅ Yes | - | Replacement string |
+| `paths` | string[] | No | Current dir | Paths to search |
+| `noRegex` | boolean | No | `false` | Treat pattern as literal |
+| `preview` | string | No | `summary` | Preview format |
+| `dryRun` | boolean | No | `false` | Preview without applying |
+
+### Example Usage
+
+**Regex replacement:**
+```
+Tool: renamify_replace
+Arguments: {
+  "pattern": "console\\.log\\((.*?)\\)",
+  "replacement": "logger.debug($1)",
+  "paths": ["src"]
+}
+```
+
+**Literal replacement:**
+```
+Tool: renamify_replace
+Arguments: {
+  "pattern": "http://localhost:3000",
+  "replacement": "https://api.example.com",
+  "noRegex": true
+}
+```
+
+### When to Use
+
+- URL or endpoint replacements
+- Regex-based transformations
+- Literal string replacements without case variations
+- When you explicitly DON'T want case transformations
+
 ## Tool Interaction Patterns
 
 ### Safe Renaming Workflow

renamify-mcp/src/index.test.ts

@@ -186,7 +186,7 @@ describe('MCP Server', () => {
 
     const tools = responseObj.result.tools;
     expect(tools).toBeInstanceOf(Array);
-    expect(tools.length).toBe(8);
+    expect(tools.length).toBe(10);
 
     const toolNames = tools.map((t: { name: string }) => t.name);
     expect(toolNames).toContain('renamify_search');
@@ -197,5 +197,7 @@ describe('MCP Server', () => {
     expect(toolNames).toContain('renamify_history');
     expect(toolNames).toContain('renamify_status');
     expect(toolNames).toContain('renamify_preview');
+    expect(toolNames).toContain('renamify_rename');
+    expect(toolNames).toContain('renamify_replace');
   });
 });

renamify-mcp/src/index.ts

@@ -271,6 +271,93 @@ export function createServer(
     }
   );
 
+  server.registerTool(
+    'renamify_rename',
+    {
+      title: 'Rename (Plan + Apply)',
+      description:
+        'Create and immediately apply a renaming plan (combines plan + apply)',
+      inputSchema: {
+        old: z.string().describe('The identifier to search for and replace'),
+        new: z.string().describe('The replacement identifier'),
+        paths: z
+          .array(z.string())
+          .optional()
+          .describe('Paths to search (defaults to current directory)'),
+        dryRun: z
+          .boolean()
+          .optional()
+          .default(false)
+          .describe('Preview changes without applying them'),
+        preview: z
+          .enum(['table', 'diff', 'summary', 'json'])
+          .optional()
+          .default('summary')
+          .describe('Preview format for the results'),
+        excludeStyles: z
+          .array(z.string())
+          .optional()
+          .describe('Case styles to exclude from transformations'),
+        includeStyles: z
+          .array(z.string())
+          .optional()
+          .describe('Additional case styles to include'),
+        onlyStyles: z
+          .array(z.string())
+          .optional()
+          .describe('Only use these specific case styles'),
+      },
+    },
+    async (params) => {
+      const result = await toolsInstance.rename(params);
+      return { content: [{ type: 'text', text: result }] };
+    }
+  );
+
+  server.registerTool(
+    'renamify_replace',
+    {
+      title: 'Replace (Regex/Literal)',
+      description:
+        'Simple regex or literal string replacement without case transformations',
+      inputSchema: {
+        pattern: z
+          .string()
+          .describe(
+            'Search pattern (regex by default, literal with noRegex=true)'
+          ),
+        replacement: z
+          .string()
+          .describe(
+            'Replacement string (supports $1, $2 capture groups in regex mode)'
+          ),
+        paths: z
+          .array(z.string())
+          .optional()
+          .describe('Paths to search (defaults to current directory)'),
+        noRegex: z
+          .boolean()
+          .optional()
+          .default(false)
+          .describe('Treat pattern as literal string instead of regex'),
+        preview: z
+          .enum(['table', 'diff', 'summary', 'json'])
+          .optional()
+          .default('summary')
+          .describe('Preview format for the results'),
+        dryRun: z
+          .boolean()
+          .optional()
+          .default(false)
+          .describe('Preview changes without applying them'),
+      },
+    },
+    async (params) => {
+      const result = await toolsInstance.replace(params);
+      return { content: [{ type: 'text', text: result }] };
+    }
+  );
+
   return server;
 }
 

renamify-mcp/src/renamify-service.ts

@@ -425,4 +425,90 @@ export class RenamifyService {
     }
     throw error;
   }
+
+  /**
+   * Rename with case-aware transformations (plan + apply in one step)
+   */
+  async rename(options: {
+    old: string;
+    new: string;
+    paths?: string[];
+    dryRun?: boolean;
+    preview?: 'table' | 'diff' | 'summary' | 'json';
+    excludeStyles?: string[];
+    includeStyles?: string[];
+    onlyStyles?: string[];
+  }): Promise<string> {
+    const args = ['rename', options.old, options.new];
+
+    // Add paths after old and new
+    if (options.paths?.length) {
+      args.push(...options.paths);
+    }
+
+    // Add preview format
+    if (options.preview) {
+      args.push('--preview', options.preview);
+    }
+
+    // Add style options
+    if (options.excludeStyles?.length) {
+      args.push('--exclude-styles', options.excludeStyles.join(','));
+    }
+    if (options.includeStyles?.length) {
+      args.push('--include-styles', options.includeStyles.join(','));
+    }
+    if (options.onlyStyles?.length) {
+      args.push('--only-styles', options.onlyStyles.join(','));
+    }
+
+    // Add dry-run flag
+    if (options.dryRun) {
+      args.push('--dry-run');
+    }
+
+    // Always skip confirmation for MCP usage
+    args.push('--yes');
+
+    return await this.executeCommand(args, 'rename');
+  }
+
+  /**
+   * Simple regex or literal replacement without case transformations
+   */
+  async replace(options: {
+    pattern: string;
+    replacement: string;
+    paths?: string[];
+    noRegex?: boolean;
+    preview?: 'table' | 'diff' | 'summary' | 'json';
+    dryRun?: boolean;
+  }): Promise<string> {
+    const args = ['replace', options.pattern, options.replacement];
+
+    // Add paths after pattern and replacement
+    if (options.paths?.length) {
+      args.push(...options.paths);
+    }
+
+    // Add no-regex flag
+    if (options.noRegex) {
+      args.push('--no-regex');
+    }
+
+    // Add preview format
+    if (options.preview) {
+      args.push('--preview', options.preview);
+    }
+
+    // Add dry-run flag
+    if (options.dryRun) {
+      args.push('--dry-run');
+    }
+
+    // Always skip confirmation for MCP usage
+    args.push('--yes');
+
+    return await this.executeCommand(args, 'replace');
+  }
 }

renamify-mcp/src/tools.ts

@@ -203,4 +203,62 @@ This is a preview only. Use 'renamify_apply' to make these changes.`;
       return `Error previewing plan: ${error instanceof Error ? error.message : String(error)}`;
     }
   }
+
+  /**
+   * Rename with case-aware transformations (plan + apply in one step)
+   */
+  async rename(params: {
+    old: string;
+    new: string;
+    paths?: string[];
+    dryRun?: boolean;
+    preview?: 'table' | 'diff' | 'summary' | 'json';
+    excludeStyles?: string[];
+    includeStyles?: string[];
+    onlyStyles?: string[];
+  }): Promise<string> {
+    try {
+      const result = await this.renamifyService.rename(params);
+
+      if (params.dryRun) {
+        return `${result}
+
+This was a dry run. Use without --dry-run to apply these changes.`;
+      }
+
+      return `${result}
+
+Renaming completed successfully. Use 'renamify_undo' if you need to revert.`;
+    } catch (error) {
+      return `Error during rename: ${error instanceof Error ? error.message : String(error)}`;
+    }
+  }
+
+  /**
+   * Simple regex or literal replacement without case transformations
+   */
+  async replace(params: {
+    pattern: string;
+    replacement: string;
+    paths?: string[];
+    noRegex?: boolean;
+    preview?: 'table' | 'diff' | 'summary' | 'json';
+    dryRun?: boolean;
+  }): Promise<string> {
+    try {
+      const result = await this.renamifyService.replace(params);
+
+      if (params.dryRun) {
+        return `${result}
+
+This was a dry run. Use without --dry-run to apply these changes.`;
+      }
+
+      return `${result}
+
+Replacement completed successfully. Use 'renamify_undo' if you need to revert.`;
+    } catch (error) {
+      return `Error during replace: ${error instanceof Error ? error.message : String(error)}`;
+    }
+  }
 }