search_loctypes

Instructions

Implementation Reference

• index.ts:431-455 (handler)

  Shared handler implementation for all 'search_*' tools including 'search_loctypes'. Derives filename from tool name ('loctypes.txt'), validates input using FileSearchSchema, checks file existence, performs search using searchFile helper, and returns paginated results.

  case "search_varptypes":
  case "search_varbittypes":
  case "search_iftypes":
  case "search_invtypes":
  case "search_loctypes":
  case "search_npctypes":
  case "search_objtypes":
  case "search_rowtypes":
  case "search_seqtypes":
  case "search_soundtypes":
  case "search_spottypes":
  case "search_spritetypes":
  case "search_tabletypes":
      const fileSearchArgs = getSchemaForTool(name).parse(args) as { query: string; page?: number; pageSize?: number };
      const { query, page: filePage = 1, pageSize: filePageSize = 10 } = fileSearchArgs;
      const filename = `${name.replace('search_', '')}.txt`;
      const filePath = path.join(getDataDir(), filename);
      
      if (!fileExists(filename)) {
          return responseToString({ error: `${filename} not found in data directory` });
      }
      
      const fileResults = await searchFile(filePath, query, filePage, filePageSize);
      return responseToString(fileResults);

• index.ts:52-56 (schema)

  Zod schema definition for input parameters of search tools (query, page, pageSize), used for validation in search_loctypes handler.

  const FileSearchSchema = z.object({
      query: z.string().describe("The term to search for in the file"),
      page: z.number().int().min(1).optional().default(1).describe("Page number for pagination"),
      pageSize: z.number().int().min(1).max(100).optional().default(10).describe("Number of results per page")
  });

• index.ts:329-332 (registration)

  Tool registration/definition returned by listTools endpoint, providing name and description.

  {
      name: "search_loctypes",
      description: "Search the loctypes.txt file for location/object type definitions in the game world.",
  },

• index.ts:102-168 (helper)

  Core searchFile helper function that reads the target file (loctypes.txt), performs case-insensitive substring search (with space-to-underscore normalization), paginates results, formats lines as ID-value pairs, and provides pagination metadata.

  async function searchFile(filePath: string, searchTerm: string, page: number = 1, pageSize: number = 10): Promise<any> {
      //replace spaces with underscores
      searchTerm = searchTerm.replace(" ", "_");
      return new Promise((resolve, reject) => {
          if (!fs.existsSync(filePath)) {
              reject(new Error(`File not found: ${filePath}`));
              return;
          }
  
          const results: {line: string, lineNumber: number}[] = [];
          const fileStream = fs.createReadStream(filePath);
          const rl = readline.createInterface({
              input: fileStream,
              crlfDelay: Infinity
          });
  
          let lineNumber = 0;
          
          rl.on('line', (line) => {
              lineNumber++;
              if (line.toLowerCase().includes(searchTerm.toLowerCase())) {
                  results.push({ line, lineNumber });
              }
          });
  
          rl.on('close', () => {
              const totalResults = results.length;
              const totalPages = Math.ceil(totalResults / pageSize);
              const startIndex = (page - 1) * pageSize;
              const endIndex = startIndex + pageSize;
              const paginatedResults = results.slice(startIndex, endIndex);
  
              // Process the results to extract key-value pairs if possible
              const formattedResults = paginatedResults.map(result => {
                  // Try to format as key-value pair (common for ID data files)
                  const parts = result.line.split(/\s+/);
                  if (parts.length >= 2) {
                      const id = parts[0];
                      const value = parts.slice(1).join(' ');
                      return {
                          ...result,
                          id,
                          value,
                          formatted: `${id}\t${value}`
                      };
                  }
                  return result;
              });
  
              resolve({
                  results: formattedResults,
                  pagination: {
                      page,
                      pageSize,
                      totalResults,
                      totalPages,
                      hasNextPage: page < totalPages,
                      hasPreviousPage: page > 1
                  }
              });
          });
  
          rl.on('error', (err) => {
              reject(err);
          });
      });
  }

• index.ts:291-294 (helper)

  Schema selector in getSchemaForTool function that routes 'search_*' tools (including search_loctypes) to the shared FileSearchSchema.

  if (toolName.startsWith("search_")) {
      return FileSearchSchema;
  }
  throw new Error(`Unknown tool: ${toolName}`);