search_kibana_api_paths

Instructions

Implementation Reference

• src/base-tools.ts:230-253 (registration)

  Registration of the 'search_kibana_api_paths' tool, including inline schema and handler function.

  server.tool(
    "search_kibana_api_paths",
    `Search Kibana API endpoints by keyword`,
    z.object({
      search: z.string().describe('Search keyword for filtering API endpoints')
    }),
    async ({ search }): Promise<ToolResponse> => {
      await buildApiIndex();
      const endpoints = searchApiEndpoints(search);
      return {
        content: [
          {
            type: "text",
            text: `Found ${endpoints.length} API endpoints: ${JSON.stringify(endpoints.map(e => ({
              method: e.method,
              path: e.path,
              summary: e.summary,
              description: e.description
            })), null, 2)}`
          }
        ]
      };
    }
  );

• src/base-tools.ts:236-252 (handler)

  Handler logic: builds the API index if necessary and searches endpoints using the helper function, returning formatted results.

  async ({ search }): Promise<ToolResponse> => {
    await buildApiIndex();
    const endpoints = searchApiEndpoints(search);
    return {
      content: [
        {
          type: "text",
          text: `Found ${endpoints.length} API endpoints: ${JSON.stringify(endpoints.map(e => ({
            method: e.method,
            path: e.path,
            summary: e.summary,
            description: e.description
          })), null, 2)}`
        }
      ]
    };
  }

• src/base-tools.ts:233-235 (schema)

  Zod input schema defining the 'search' parameter as a string.

  z.object({
    search: z.string().describe('Search keyword for filtering API endpoints')
  }),

• src/base-tools.ts:95-104 (helper)

  Helper function that filters the global apiEndpointIndex array based on the query string matching path, description, summary, or tags.

  function searchApiEndpoints(query: string): ApiEndpoint[] {
    if (!isIndexBuilt) throw new Error('API index not built yet');
    const q = query.toLowerCase();
    return apiEndpointIndex.filter(e =>
      e.path.toLowerCase().includes(q) ||
      (e.description && e.description.toLowerCase().includes(q)) ||
      (e.summary && e.summary.toLowerCase().includes(q)) ||
      (e.tags && e.tags.some(tag => tag.toLowerCase().includes(q)))
    );
  }

• src/base-tools.ts:32-93 (helper)

  Helper function that loads and parses the Kibana OpenAPI YAML file to build the global apiEndpointIndex used by the search tool.

  async function buildApiIndex(): Promise<void> {
    if (isIndexBuilt) return;
    
    // Enhanced path resolution for both compiled JS and direct TS execution
    const possiblePaths = [
      // Environment variable takes highest priority
      process.env.KIBANA_OPENAPI_YAML_PATH,
      // Current working directory
      path.join(process.cwd(), 'kibana-openapi-source.yaml'),
      // Relative to the source file
      path.join(__dirname, 'kibana-openapi-source.yaml'),
      // One level up from source file (for ts-node execution)
      path.resolve(__dirname, '..', 'kibana-openapi-source.yaml'),
      // dist directory for compiled JS
      path.join(process.cwd(), 'dist', 'src', 'kibana-openapi-source.yaml')
    ].filter((p): p is string => typeof p === 'string' && p.length > 0);
  
    for (const p of possiblePaths) {
      if (fs.existsSync(p)) {
        YAML_FILE_PATH = p;
        console.warn(`Using YAML file from: ${p}`);
        break;
      }
    }
  
    if (!YAML_FILE_PATH) {
      console.error('Could not find kibana-openapi-source.yaml file');
      isIndexBuilt = true;
      return;
    }
  
    try {
      const yamlContent = fs.readFileSync(YAML_FILE_PATH, 'utf8');
      openApiDoc = yaml.load(yamlContent);
      
      if (!openApiDoc || !openApiDoc.paths) {
        throw new Error('Invalid YAML file structure: missing paths');
      }
  
      for (const [pathStr, pathObj] of Object.entries(openApiDoc.paths)) {
        for (const [method, methodObj] of Object.entries(pathObj as Record<string, any>)) {
          if (["get", "post", "put", "delete", "patch"].includes(method)) {
            apiEndpointIndex.push({
              path: pathStr as string,
              method: method.toUpperCase(),
              description: (methodObj as any).description,
              summary: (methodObj as any).summary,
              parameters: (methodObj as any).parameters,
              requestBody: (methodObj as any).requestBody,
              responses: (methodObj as any).responses,
              deprecated: (methodObj as any).deprecated,
              tags: (methodObj as any).tags
            });
          }
        }
      }
      isIndexBuilt = true;
    } catch (error) {
      console.error('Error loading or parsing YAML file:', error);
      throw error;
    }
  }