search_in_file

Instructions

Implementation Reference

• ripgrep.ts:171-207 (handler)

  Core handler function that performs the ripgrep search within a specific file, constructing arguments and executing the command.

  export async function ripgrepSearchInFile(
    filePath: string,
    pattern: string,
    options: {
      caseInsensitive?: boolean;
      contextLines?: number;
      literalString?: boolean;
      wordBoundary?: boolean;
    } = {}
  ): Promise<RipgrepResult> {
    const args: string[] = ['--json', '--no-config'];
    
    if (options.contextLines !== undefined && options.contextLines > 0) {
      args.push('-C', options.contextLines.toString());
    }
    
    if (options.caseInsensitive) {
      args.push('-i');
    }
    
    if (options.literalString) {
      args.push('-F');
    }
    
    if (options.wordBoundary) {
      args.push('-w');
    }
    
    args.push(pattern);
    args.push(filePath);
    
    const startTime = Date.now();
    const result = await executeRipgrep(args, pattern, [filePath]);
    result.summary.searchTimeMs = Date.now() - startTime;
    
    return result;
  }

• index.ts:169-206 (registration)

  Registration of the 'search_in_file' tool in the MCP tools list, including name, description, and JSON input schema.

  {
    name: 'search_in_file',
    description: 'Search for patterns within a specific file using ripgrep. Like Ctrl+F but with regex support. Useful for finding specific sections in a known file.',
    inputSchema: {
      type: 'object',
      properties: {
        path: {
          type: 'string',
          description: 'File path to search within'
        },
        pattern: {
          type: 'string',
          description: 'Regex pattern to search for'
        },
        caseInsensitive: {
          type: 'boolean',
          description: 'Ignore case in search. Default: true',
          default: true
        },
        contextLines: {
          type: 'number',
          description: 'Lines of context before/after match',
          default: 3
        },
        literalString: {
          type: 'boolean',
          description: 'Treat pattern as literal string, not regex',
          default: false
        },
        wordBoundary: {
          type: 'boolean',
          description: 'Match whole words only',
          default: false
        }
      },
      required: ['path', 'pattern']
    }
  },

• index.ts:365-372 (schema)

  Zod validation schema matching the tool inputSchema for runtime input validation in the dispatch handler.

  const schema = z.object({
    path: z.string(),
    pattern: z.string(),
    caseInsensitive: z.boolean().optional().default(true),
    contextLines: z.number().optional().default(3),
    literalString: z.boolean().optional().default(false),
    wordBoundary: z.boolean().optional().default(false)
  });

• index.ts:364-388 (handler)

  MCP server dispatch handler case for 'search_in_file' that validates arguments, calls the core handler, and formats the response.

  case 'search_in_file': {
    const schema = z.object({
      path: z.string(),
      pattern: z.string(),
      caseInsensitive: z.boolean().optional().default(true),
      contextLines: z.number().optional().default(3),
      literalString: z.boolean().optional().default(false),
      wordBoundary: z.boolean().optional().default(false)
    });
    const { path, pattern, caseInsensitive, contextLines, literalString, wordBoundary } = schema.parse(args);
    const validatedPath = await validatePath(path);
    
    const result = await ripgrepSearchInFile(
      validatedPath,
      pattern,
      { caseInsensitive, contextLines, literalString, wordBoundary }
    );
    
    return {
      content: [{
        type: 'text',
        text: JSON.stringify(result, null, 2)
      }]
    };
  }

• ripgrep.ts:30-52 (helper)

  Type definition for the output structure returned by search functions.

  export interface RipgrepResult {
    query: {
      pattern: string;
      searchedPaths: string[];
      options?: any;
    };
    summary: {
      totalMatches: number;
      filesWithMatches: number;
      searchTimeMs: number;
    };
    pagination?: {
      page: number;
      pageSize: number;
      totalPages: number;
      hasMore: boolean;
    };
    matches: RipgrepMatch[];
    ripgrepDetails: {
      commandUsed: string;
      explanation: string;
    };
    suggestions?: string[];