mcp-fs-shell-windows 0.2.4

package/dist/move_files/handler.js

@@ -0,0 +1,68 @@
+import fs from "fs/promises";
+import path from "path";
+import { validatePath, ensureDirectoryExists } from "../helpers/path.js";
+export async function handleMoveFiles(items, overwrite, allowedDirectories) {
+    const results = [];
+    const errors = [];
+    await Promise.all(items.map(async (item) => {
+        try {
+            // Validate both paths are within allowed directories
+            const validSource = await validatePath(item.source, allowedDirectories);
+            const validDestination = await validatePath(item.destination, allowedDirectories);
+            // Check if source exists
+            try {
+                await fs.access(validSource);
+            }
+            catch (error) {
+                throw new Error(`Source does not exist: ${item.source}`);
+            }
+            // Check if destination exists and handle based on overwrite flag
+            let destExists = true;
+            try {
+                await fs.access(validDestination);
+            }
+            catch (error) {
+                const code = error.code;
+                if (code === 'ENOENT') {
+                    destExists = false;
+                }
+                else {
+                    throw error;
+                }
+            }
+            if (destExists) {
+                if (!overwrite) {
+                    throw new Error(`Destination already exists: ${item.destination}`);
+                }
+                // Remove existing destination so fs.rename can replace it
+                const destStats = await fs.stat(validDestination);
+                if (destStats.isDirectory()) {
+                    await fs.rm(validDestination, { recursive: true, force: true });
+                }
+                else {
+                    await fs.unlink(validDestination);
+                }
+            }
+            // Create parent directory for destination if it doesn't exist
+            const destDir = path.dirname(validDestination);
+            await ensureDirectoryExists(destDir);
+            // Move the file
+            await fs.rename(validSource, validDestination);
+            results.push(`Successfully moved ${item.source} to ${item.destination}`);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            errors.push(`Failed to move ${item.source} to ${item.destination}: ${errorMessage}`);
+        }
+    }));
+    // Format the results
+    const successCount = results.length;
+    const errorCount = errors.length;
+    let output = `Processed ${successCount + errorCount} move operations:\n`;
+    output += `- ${successCount} items moved successfully\n`;
+    if (errorCount > 0) {
+        output += `- ${errorCount} operations failed\n\n`;
+        output += "Errors:\n" + errors.join("\n");
+    }
+    return output;
+}

package/dist/move_files/schema.js

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export const MoveFilesArgsSchema = z.object({
+    items: z.array(z.object({
+        source: z.string().describe("Path to the source file or directory"),
+        destination: z.string().describe("Path to the destination file or directory"),
+    })).describe("Array of source-destination pairs"),
+    overwrite: z.boolean().default(false).describe("Whether to overwrite existing files at destination"),
+});

package/dist/patch_files/handler.js

@@ -0,0 +1,34 @@
+import { validatePath } from "../helpers/path.js";
+import { applyFilePatches } from "./helpers.js";
+export async function handlePatchFiles(files, dryRun, options, allowedDirectories) {
+    const results = [];
+    const errors = [];
+    await Promise.all(files.map(async (file) => {
+        try {
+            // Validate path is within allowed directories
+            const validPath = await validatePath(file.path, allowedDirectories);
+            // Apply patches to the file
+            const result = await applyFilePatches(validPath, file.patches, dryRun, options);
+            results.push(`File: ${file.path}\n${result}`);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            errors.push(`Failed to patch ${file.path}: ${errorMessage}`);
+        }
+    }));
+    // Format the results
+    const successCount = results.length;
+    const errorCount = errors.length;
+    let output = `Processed ${successCount + errorCount} files:\n`;
+    output += `- ${successCount} files patched successfully\n`;
+    if (errorCount > 0) {
+        output += `- ${errorCount} files failed\n\n`;
+        output += "Errors:\n" + errors.join("\n\n");
+    }
+    // Add patch results for successful patches
+    if (successCount > 0) {
+        output += "\n\nPatch Results:\n" + "=".repeat(40) + "\n";
+        output += results.join("\n" + "=".repeat(40) + "\n");
+    }
+    return output;
+}

package/dist/patch_files/helpers.js

@@ -0,0 +1,103 @@
+import fs from "fs/promises";
+import { createUnifiedDiff, normalizeLineEndings } from "../helpers/diff.js";
+export async function applyFilePatches(filePath, patches, dryRun = false, options = { preserveIndentation: true }) {
+    // Read file content and normalize line endings
+    const content = normalizeLineEndings(await fs.readFile(filePath, "utf-8"));
+    // Split content into lines
+    const contentLines = content.split("\n");
+    // Sort patches by line number in descending order so every patch references
+    // the original line numbers (earlier lines keep their positions).
+    const sortedPatches = [...patches].sort((a, b) => b.startLine - a.startLine);
+    // Apply patches sequentially
+    let modifiedContentLines = [...contentLines];
+    const patchResults = [];
+    for (const patch of sortedPatches) {
+        const { startLine, endLine, newText } = patch;
+        const action = patch.action ?? "replace";
+        const patchResult = { patch, applied: false };
+        if (action === "insertBefore") {
+            // Insert newText before startLine (1 = before the first line;
+            // contentLines.length + 1 = append after the last line).
+            if (startLine < 1 || startLine > contentLines.length + 1) {
+                patchResult.message = `Invalid insert position: ${startLine} (file has ${contentLines.length} lines; valid positions 1-${contentLines.length + 1})`;
+                patchResults.push(patchResult);
+                throw new Error(patchResult.message);
+            }
+            const normalizedNew = normalizeLineEndings(newText);
+            let newLines = normalizedNew.split("\n");
+            if (options.preserveIndentation && newText.length > 0) {
+                // Detect indentation from the line being inserted before
+                const refIndex = Math.min(startLine - 1, contentLines.length - 1);
+                const originalIndent = modifiedContentLines[refIndex]?.match(/^\s*/)?.[0] || "";
+                newLines = newLines.map((line, idx) => {
+                    if (idx === 0)
+                        return originalIndent + line.trimStart();
+                    return line;
+                });
+            }
+            modifiedContentLines.splice(startLine - 1, 0, ...newLines);
+        }
+        else if (action === "delete") {
+            // Remove lines startLine-endLine entirely
+            if (startLine < 1 || endLine < startLine || endLine > contentLines.length) {
+                patchResult.message = `Invalid line range: ${startLine}-${endLine} (file has ${contentLines.length} lines)`;
+                patchResults.push(patchResult);
+                throw new Error(patchResult.message);
+            }
+            modifiedContentLines.splice(startLine - 1, endLine - startLine + 1);
+        }
+        else {
+            // replace (default): original behavior
+            if (startLine < 1 || endLine < startLine || endLine > contentLines.length) {
+                patchResult.message = `Invalid line range: ${startLine}-${endLine} (file has ${contentLines.length} lines)`;
+                patchResults.push(patchResult);
+                throw new Error(patchResult.message);
+            }
+            const normalizedNew = normalizeLineEndings(newText);
+            const newLines = normalizedNew.split("\n");
+            if (options.preserveIndentation) {
+                // Detect indentation from the first line being replaced
+                const originalIndent = modifiedContentLines[startLine - 1].match(/^\s*/)?.[0] || "";
+                // Apply indentation to new lines
+                const indentedNewLines = newLines.map((line, idx) => {
+                    if (idx === 0)
+                        return originalIndent + line.trimStart();
+                    return line;
+                });
+                // Replace lines
+                modifiedContentLines.splice(startLine - 1, endLine - startLine + 1, ...indentedNewLines);
+            }
+            else {
+                // Replace lines without preserving indentation
+                modifiedContentLines.splice(startLine - 1, endLine - startLine + 1, ...newLines);
+            }
+        }
+        patchResult.applied = true;
+        patchResults.push(patchResult);
+    }
+    const modifiedContent = modifiedContentLines.join("\n");
+    // Create unified diff
+    const diff = createUnifiedDiff(content, modifiedContent, filePath, filePath);
+    // Format diff with appropriate number of backticks
+    let numBackticks = 3;
+    while (diff.includes("`".repeat(numBackticks))) {
+        numBackticks++;
+    }
+    // Build result with detailed information
+    let resultText = `${"`".repeat(numBackticks)}diff\n${diff}${"`".repeat(numBackticks)}\n\n`;
+    // Add patch details
+    resultText += "Patch details:\n";
+    patchResults.forEach((result, i) => {
+        const { startLine, endLine } = result.patch;
+        const action = result.patch.action ?? "replace";
+        const range = action === "insertBefore" ? `before line ${startLine}` : `lines ${startLine}-${endLine}`;
+        resultText += `Patch ${i + 1}: ${result.applied ? "APPLIED" : "FAILED"} (${action}, ${range})\n`;
+        if (result.message) {
+            resultText += `  Message: ${result.message}\n`;
+        }
+    });
+    if (!dryRun) {
+        await fs.writeFile(filePath, modifiedContent, "utf-8");
+    }
+    return resultText;
+}

package/dist/patch_files/schema.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+// Options for patch operations
+const PatchOptionsSchema = z.object({
+    preserveIndentation: z.boolean().default(true).describe("Preserve indentation when replacing/inserting text")
+});
+export const PatchFilesArgsSchema = z.object({
+    files: z.array(z.object({
+        path: z.string().describe("Path to the file to patch"),
+        patches: z.array(z.object({
+            startLine: z.number().int().min(1).describe("Line number where the patch starts (1-indexed). For insertBefore, the line to insert before (use total lines + 1 to append to the end)."),
+            endLine: z.number().int().min(1).describe("Line number where the patch ends (1-indexed). Ignored for insertBefore."),
+            newText: z.string().describe("Text to insert/replace with. Ignored for delete."),
+            action: z.enum(["replace", "insertBefore", "delete"]).optional().default("replace").describe("replace (default): replace lines startLine-endLine with newText. insertBefore: insert newText before startLine. delete: remove lines startLine-endLine."),
+        })).describe("Array of patches to apply to this file")
+    })).describe("Array of files to patch"),
+    dryRun: z.boolean().default(false).describe("Preview changes using git-style diff format"),
+    options: PatchOptionsSchema.optional().describe("Options for controlling patch behavior")
+});

package/dist/read_files/handler.js

@@ -0,0 +1,36 @@
+import fs from "fs/promises";
+import { validatePath } from "../helpers/path.js";
+export async function handleReadFiles(filePaths, allowedDirectories, offset, limit) {
+    const results = await Promise.all(filePaths.map(async (filePath) => {
+        try {
+            const validPath = await validatePath(filePath, allowedDirectories);
+            const content = await fs.readFile(validPath, "utf-8");
+            // Split into lines, keeping original line numbers
+            const lines = content.split("\n");
+            const total = lines.length;
+            let startLine = 1;
+            let endLine = total;
+            if (offset !== undefined || limit !== undefined) {
+                startLine = offset ?? 1;
+                if (startLine > total) {
+                    throw new Error(`offset ${startLine} is beyond end of file (${total} lines)`);
+                }
+                endLine = limit !== undefined ? Math.min(total, startLine + limit - 1) : total;
+            }
+            // Format content with line numbers
+            const numberedContent = lines
+                .slice(startLine - 1, endLine)
+                .map((line, idx) => `${startLine + idx}: ${line}`)
+                .join("\n");
+            const header = offset !== undefined || limit !== undefined
+                ? `${filePath}: [lines ${startLine}-${endLine} of ${total}]\n`
+                : `${filePath}:\n`;
+            return `${header}${numberedContent}\n`;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return `${filePath}: Error - ${errorMessage}`;
+        }
+    }));
+    return results.join("\n---\n");
+}

package/dist/read_files/schema.js

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export const ReadFilesArgsSchema = z.object({
+    paths: z.array(z.string()),
+    offset: z.number().int().min(1).optional().describe("Start reading from this line number (1-indexed). Omit to read from the beginning."),
+    limit: z.number().int().min(1).optional().describe("Maximum number of lines to read per file. Omit to read to the end."),
+});

package/dist/search_files/handler.js

@@ -0,0 +1,15 @@
+import { validatePath } from "../helpers/path.js";
+import { searchFiles } from "./helpers.js";
+export async function handleSearchFiles(directoryPath, pattern, excludePatterns, maxResults, offset, allowedDirectories) {
+    const validPath = await validatePath(directoryPath, allowedDirectories);
+    const { results, stopped } = await searchFiles(validPath, pattern, excludePatterns, allowedDirectories, maxResults, offset);
+    const shown = results.slice(offset - 1);
+    if (shown.length === 0) {
+        return stopped
+            ? `Found at least ${offset - 1} matching files, but offset ${offset} is beyond the collected range`
+            : "No matches found";
+    }
+    const end = offset + shown.length - 1;
+    const totalText = stopped ? `at least ${results.length}` : `${results.length}`;
+    return `Found ${totalText} files matching "${pattern}" (showing ${offset}-${end})\n\n` + shown.join("\n");
+}

package/dist/search_files/helpers.js

@@ -0,0 +1,71 @@
+import fs from "fs/promises";
+import path from "path";
+import { minimatch } from "minimatch";
+import { validatePath } from "../helpers/path.js";
+export async function searchFiles(rootPath, pattern, excludePatterns = [], allowedDirectories, maxResults = 500, offset = 1) {
+    const results = [];
+    const effectiveCap = offset - 1 + maxResults;
+    let stopped = false;
+    async function search(currentPath) {
+        if (stopped)
+            return;
+        let entries;
+        try {
+            entries = await fs.readdir(currentPath, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (stopped)
+                break;
+            const fullPath = path.join(currentPath, entry.name);
+            try {
+                // Validate each path before processing
+                await validatePath(fullPath, allowedDirectories);
+                // Check if path matches any exclude pattern
+                const relativePath = path.relative(rootPath, fullPath);
+                const shouldExclude = excludePatterns.some((excludePattern) => {
+                    // Handle different pattern formats
+                    // 1. If pattern already contains glob characters, use as is
+                    // 2. If pattern is a simple name, match anywhere in path
+                    // 3. If pattern is a path segment, match that segment
+                    let globPattern = excludePattern;
+                    if (!excludePattern.includes("*") && !excludePattern.includes("?")) {
+                        if (excludePattern.includes("/")) {
+                            globPattern = `**/${excludePattern}/**`;
+                        }
+                        else {
+                            globPattern = `**/*${excludePattern}*/**`;
+                        }
+                    }
+                    return minimatch(relativePath, globPattern, {
+                        dot: true,
+                        nocase: true,
+                        matchBase: true,
+                    });
+                });
+                if (shouldExclude) {
+                    continue;
+                }
+                // Case-insensitive filename matching
+                if (entry.name.toLowerCase().includes(pattern.toLowerCase())) {
+                    results.push(fullPath);
+                    if (results.length >= effectiveCap) {
+                        stopped = true;
+                        break;
+                    }
+                }
+                if (entry.isDirectory()) {
+                    await search(fullPath);
+                }
+            }
+            catch (error) {
+                // Skip invalid paths during search
+                continue;
+            }
+        }
+    }
+    await search(rootPath);
+    return { results, stopped };
+}

package/dist/search_files/schema.js

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export const SearchFilesArgsSchema = z.object({
+    path: z.string(),
+    pattern: z.string(),
+    excludePatterns: z.array(z.string()).optional().default([]),
+    maxResults: z.number().optional().default(500).describe("Maximum number of results to return. Default: 500."),
+    offset: z.number().int().min(1).optional().default(1).describe("1-indexed result number to start from. Default: 1."),
+});

package/dist/search_glob/handler.js

@@ -0,0 +1,77 @@
+import fs from "fs/promises";
+import path from "path";
+import { validatePath } from "../helpers/path.js";
+import { minimatch } from "minimatch";
+export async function handleSearchGlob(searchPath, pattern, excludePatterns, maxResults, offset, allowedDirectories) {
+    // Validate root path
+    const validRootPath = await validatePath(searchPath, allowedDirectories);
+    const results = [];
+    const effectiveCap = offset - 1 + maxResults;
+    let searchAborted = false;
+    async function findMatches(currentPath) {
+        if (searchAborted)
+            return;
+        try {
+            const entries = await fs.readdir(currentPath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (searchAborted)
+                    break;
+                const fullPath = path.join(currentPath, entry.name);
+                try {
+                    // Validate each path before processing
+                    await validatePath(fullPath, allowedDirectories);
+                    // Get relative path for glob matching
+                    const relativePath = path.relative(validRootPath, fullPath);
+                    // Check if path should be excluded
+                    const shouldExclude = excludePatterns.some((excludePattern) => {
+                        return minimatch(relativePath, excludePattern, { dot: true });
+                    });
+                    if (shouldExclude) {
+                        continue;
+                    }
+                    // Check if the path matches the provided pattern
+                    if (minimatch(relativePath, pattern, { dot: true })) {
+                        results.push(fullPath);
+                        if (results.length >= effectiveCap) {
+                            searchAborted = true;
+                            break;
+                        }
+                    }
+                    // Recursively search directories
+                    if (entry.isDirectory()) {
+                        await findMatches(fullPath);
+                    }
+                }
+                catch (error) {
+                    // Skip invalid paths during search
+                    continue;
+                }
+            }
+        }
+        catch (error) {
+            // Skip directories we can't read
+            return;
+        }
+    }
+    await findMatches(validRootPath);
+    // Format the results
+    let output = "";
+    if (results.length === 0) {
+        output = `No files matching pattern: ${pattern}\n`;
+    }
+    else {
+        // Sort results by path, then apply pagination
+        results.sort();
+        const shown = results.slice(offset - 1);
+        const end = offset + shown.length - 1;
+        output = `Found ${results.length} files matching pattern: ${pattern} (showing ${offset}-${end})`;
+        if (searchAborted) {
+            output += ` (search stopped at ${effectiveCap} collected files)`;
+        }
+        output += "\n\n";
+        for (const result of shown) {
+            output += `${result}\n`;
+        }
+    }
+    return output;
+}

package/dist/search_glob/schema.js

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export const SearchGlobArgsSchema = z.object({
+    path: z.string().describe("Root directory to search in"),
+    pattern: z.string().describe("Glob pattern to match files against (e.g. '**/*.js')"),
+    excludePatterns: z.array(z.string()).optional().default([]).describe("Glob patterns to exclude"),
+    maxResults: z.number().optional().default(500).describe("Maximum number of results to return"),
+    offset: z.number().int().min(1).optional().default(1).describe("1-indexed result number to start from. Default: 1."),
+});

package/dist/search_regex/handler.js

@@ -0,0 +1,159 @@
+import fs from "fs/promises";
+import path from "path";
+import { validatePath } from "../helpers/path.js";
+import { minimatch } from "minimatch";
+export async function handleSearchRegex(searchPath, pattern, filePatterns, excludePatterns, maxResults, caseSensitive, offset, allowedDirectories) {
+    // Validate root path (may be a directory or a single file)
+    const validRootPath = await validatePath(searchPath, allowedDirectories);
+    const results = [];
+    let filesSearched = 0;
+    let matchesFound = 0;
+    let searchAborted = false;
+    const effectiveCap = offset - 1 + maxResults;
+    // Create regex pattern
+    const regexFlags = caseSensitive ? "mg" : "img";
+    let regex;
+    try {
+        regex = new RegExp(pattern, regexFlags);
+    }
+    catch (error) {
+        throw new Error(`Invalid regular expression: ${pattern}`);
+    }
+    async function scanFile(fullPath) {
+        if (searchAborted)
+            return;
+        try {
+            filesSearched++;
+            const content = await fs.readFile(fullPath, "utf-8");
+            const lines = content.split("\n");
+            regex.lastIndex = 0;
+            let match;
+            while ((match = regex.exec(content)) !== null) {
+                matchesFound++;
+                // Find the line number for this match
+                const matchPosition = match.index;
+                let lineNumber = 0;
+                let charCount = 0;
+                for (let i = 0; i < lines.length; i++) {
+                    charCount += lines[i].length + 1; // +1 for the newline
+                    if (charCount > matchPosition) {
+                        lineNumber = i + 1;
+                        break;
+                    }
+                }
+                // Get the line content
+                const lineContent = lines[lineNumber - 1]?.trim() || "";
+                results.push({
+                    file: fullPath,
+                    line: lineNumber,
+                    content: lineContent,
+                    match: match[0],
+                });
+                if (results.length >= effectiveCap) {
+                    searchAborted = true;
+                    break;
+                }
+                // Guard against zero-length matches (e.g. pattern "a*") looping forever
+                if (match[0].length === 0) {
+                    regex.lastIndex++;
+                }
+            }
+        }
+        catch (error) {
+            // Skip files that can't be read as text
+        }
+    }
+    async function searchDirectory(dirPath) {
+        if (searchAborted)
+            return;
+        try {
+            const entries = await fs.readdir(dirPath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (searchAborted)
+                    break;
+                const fullPath = path.join(dirPath, entry.name);
+                try {
+                    // Validate each path before processing
+                    await validatePath(fullPath, allowedDirectories);
+                    // Check if path matches any exclude pattern
+                    const relativePath = path.relative(validRootPath, fullPath);
+                    const shouldExclude = excludePatterns.some((excludePattern) => {
+                        const globPattern = excludePattern.includes("*") ? excludePattern : `**/${excludePattern}/**`;
+                        return minimatch(relativePath, globPattern, { dot: true });
+                    });
+                    if (shouldExclude) {
+                        continue;
+                    }
+                    if (entry.isDirectory()) {
+                        // Recursively search subdirectories
+                        await searchDirectory(fullPath);
+                    }
+                    else if (entry.isFile()) {
+                        // Check if file matches the file patterns (if any were provided)
+                        const shouldInclude = filePatterns.length === 0 ||
+                            filePatterns.some((filePattern) => {
+                                return minimatch(entry.name, filePattern, { nocase: true });
+                            });
+                        if (shouldInclude) {
+                            await scanFile(fullPath);
+                        }
+                    }
+                }
+                catch (error) {
+                    // Skip invalid paths during search
+                    continue;
+                }
+            }
+        }
+        catch (error) {
+            // Skip directories we can't read
+            return;
+        }
+    }
+    const rootStat = await fs.stat(validRootPath);
+    if (rootStat.isFile()) {
+        // Single-file search: apply the same file-pattern filter to the name
+        const shouldInclude = filePatterns.length === 0 ||
+            filePatterns.some((filePattern) => minimatch(path.basename(validRootPath), filePattern, { nocase: true }));
+        if (shouldInclude) {
+            await scanFile(validRootPath);
+        }
+    }
+    else {
+        await searchDirectory(validRootPath);
+    }
+    // Format the results
+    let output = "";
+    const shown = results.slice(offset - 1);
+    if (matchesFound === 0) {
+        output = `No matches found for regex: ${pattern}\n`;
+        output += `Searched ${filesSearched} files\n`;
+    }
+    else if (shown.length === 0) {
+        output = `Found ${matchesFound} matches in ${results.length} locations (offset ${offset} is beyond the collected range)\n`;
+    }
+    else {
+        const end = offset + shown.length - 1;
+        output = `Found ${matchesFound} matches in ${results.length} locations (showing ${offset}-${end})`;
+        if (searchAborted) {
+            output += ` (search stopped at ${effectiveCap} collected matches)`;
+        }
+        output += "\n\n";
+        // Group by file for more readable output
+        const fileGroups = new Map();
+        for (const result of shown) {
+            if (!fileGroups.has(result.file)) {
+                fileGroups.set(result.file, []);
+            }
+            fileGroups.get(result.file)?.push(result);
+        }
+        for (const [file, fileResults] of fileGroups.entries()) {
+            output += `File: ${file}\n`;
+            for (const result of fileResults) {
+                output += `  Line ${result.line}: ${result.content}\n`;
+            }
+            output += "\n";
+        }
+    }
+    return output;
+}

package/dist/search_regex/schema.js

@@ -0,0 +1,10 @@
+import { z } from "zod";
+export const SearchRegexArgsSchema = z.object({
+    path: z.string().describe("Root directory to search in, or a single file to search"),
+    pattern: z.string().describe("Regular expression pattern to search for in file contents"),
+    filePatterns: z.array(z.string()).optional().default([]).describe("File patterns to include (e.g. '*.js', '*.ts')"),
+    excludePatterns: z.array(z.string()).optional().default([]).describe("Patterns to exclude from search"),
+    maxResults: z.number().optional().default(100).describe("Maximum number of results to return"),
+    offset: z.number().int().min(1).optional().default(1).describe("1-indexed match number to start from. Default: 1."),
+    caseSensitive: z.boolean().optional().default(false).describe("Whether the search should be case-sensitive"),
+});