File Finder MCP Server

Instructions

Implementation Reference

• src/index.ts:20-46 (handler)

  Core implementation of the search_files tool logic in the FileFinder class, which recursively walks the directory to find files matching the fragment.

  class FileFinder {
    searchFiles(fragment: string): FileInfo[] {
      const results: FileInfo[] = [];
      this.walkDir('.', fragment, results);
      return results;
    }
  
    private walkDir(dir: string, fragment: string, results: FileInfo[]): void {
      const files = fs.readdirSync(dir, { withFileTypes: true });
      
      for (const file of files) {
        const fullPath = path.join(dir, file.name);
        
        if (file.isDirectory()) {
          this.walkDir(fullPath, fragment, results);
        } else if (file.name.includes(fragment)) {
          const stats = fs.statSync(fullPath);
          results.push({
            name: file.name,
            path: path.resolve(fullPath),
            size: stats.size,
            created: stats.birthtime.toLocaleString()
          });
        }
      }
    }
  }

• src/index.ts:83-92 (schema)

  Input schema definition for the search_files tool.

  inputSchema: {
    type: 'object',
    properties: {
      fragment: {
        type: 'string',
        description: 'Text fragment to search for in file names',
      },
    },
    required: ['fragment'],
  },

• src/index.ts:78-95 (registration)

  Registration of the search_files tool in the ListToolsRequestSchema handler.

  this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
    tools: [
      {
        name: 'search_files',
        description: 'Search for files containing a specified fragment in their names',
        inputSchema: {
          type: 'object',
          properties: {
            fragment: {
              type: 'string',
              description: 'Text fragment to search for in file names',
            },
          },
          required: ['fragment'],
        },
      },
    ],
  }));

• src/index.ts:97-137 (handler)

  MCP CallToolRequestSchema handler that handles calls to search_files, validates parameters, executes the search, and returns results or errors.

  this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
    if (request.params.name !== 'search_files') {
      throw new McpError(
        ErrorCode.MethodNotFound,
        `Unknown tool: ${request.params.name}`
      );
    }
  
    const args = request.params.arguments as { fragment: string };
    
    if (!args.fragment) {
      throw new McpError(
        ErrorCode.InvalidParams,
        'Missing required parameter: fragment'
      );
    }
  
    try {
      const results = this.fileFinder.searchFiles(args.fragment);
      
      return {
        content: [
          {
            type: 'text',
            text: JSON.stringify(results, null, 2),
          },
        ],
      };
    } catch (error) {
      console.error('Error searching files:', error);
      return {
        content: [
          {
            type: 'text',
            text: `Error searching files: ${error instanceof Error ? error.message : String(error)}`,
          },
        ],
        isError: true,
      };
    }
  });