test: add unit tests for list_indexes and discovery vs fixed mode

Agent-Id: agent-5dbe4a24-0e78-4075-b85c-d6ff632c88c7

Author: richhankins

src/clients/mcp-server.test.ts

@@ -6,6 +6,10 @@ import { describe, it, expect, vi, beforeEach } from "vitest";
 import type { IndexState } from "../core/types.js";
 import type { IndexStoreReader } from "../stores/types.js";
 import type { Source } from "../sources/types.js";
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
 
 // Try to import SDK-dependent modules
 let createMCPServer: typeof import("./mcp-server.js").createMCPServer;
@@ -134,3 +138,209 @@ describe.skipIf(sdkLoadError !== null)("MCP Server Unit Tests", () => {
   });
 });
 
+// Tests for list_indexes tool and discovery vs fixed mode
+describe.skipIf(sdkLoadError !== null || !hasApiCredentials)(
+  "list_indexes tool and discovery mode",
+  () => {
+    describe("list_indexes tool", () => {
+      it("returns available indexes with metadata", async () => {
+        const mockState = createMockState();
+        const store = createMockStore(mockState);
+
+        const server = await createMCPServer({
+          store,
+          indexNames: ["test-key"],
+        });
+
+        // Get the ListToolsRequestSchema handler
+        const listToolsHandler = (server as any).requestHandlers.get(
+          ListToolsRequestSchema
+        );
+        expect(listToolsHandler).toBeDefined();
+
+        // Call the handler to get tools
+        const result = await listToolsHandler();
+        const listIndexesTool = result.tools.find(
+          (t: any) => t.name === "list_indexes"
+        );
+        expect(listIndexesTool).toBeDefined();
+        expect(listIndexesTool.description).toContain("available indexes");
+      });
+
+      it("returns 'No indexes available' message when empty in discovery mode", async () => {
+        const store = createMockStore(null);
+        // Mock store.list() to return empty array for discovery mode
+        store.list = vi.fn().mockResolvedValue([]);
+
+        const server = await createMCPServer({
+          store,
+          indexNames: [],
+          discovery: true,
+        });
+
+        // Get the CallToolRequestSchema handler
+        const callToolHandler = (server as any).requestHandlers.get(
+          CallToolRequestSchema
+        );
+        expect(callToolHandler).toBeDefined();
+
+        // Call list_indexes
+        const result = await callToolHandler({
+          params: {
+            name: "list_indexes",
+            arguments: {},
+          },
+        });
+
+        expect(result.content[0].text).toContain("No indexes available");
+      });
+
+      it("handles errors gracefully and returns isError: true", async () => {
+        const store = createMockStore(createMockState());
+        // Mock store.list() to throw an error
+        store.list = vi.fn().mockRejectedValue(new Error("Store error"));
+
+        const server = await createMCPServer({
+          store,
+          indexNames: ["test-key"],
+          discovery: true,
+        });
+
+        // Get the CallToolRequestSchema handler
+        const callToolHandler = (server as any).requestHandlers.get(
+          CallToolRequestSchema
+        );
+
+        // Call list_indexes
+        const result = await callToolHandler({
+          params: {
+            name: "list_indexes",
+            arguments: {},
+          },
+        });
+
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain("Error listing indexes");
+      });
+    });
+
+    describe("discovery vs fixed mode", () => {
+      it("fixed mode includes enum in tool schemas for index_name", async () => {
+        const mockState = createMockState();
+        const store = createMockStore(mockState);
+
+        const server = await createMCPServer({
+          store,
+          indexNames: ["test-key"],
+          discovery: false, // Fixed mode
+        });
+
+        // Get the ListToolsRequestSchema handler
+        const listToolsHandler = (server as any).requestHandlers.get(
+          ListToolsRequestSchema
+        );
+        const result = await listToolsHandler();
+
+        // Check search tool has enum
+        const searchTool = result.tools.find((t: any) => t.name === "search");
+        expect(searchTool.inputSchema.properties.index_name.enum).toBeDefined();
+        expect(searchTool.inputSchema.properties.index_name.enum).toContain(
+          "test-key"
+        );
+
+        // Check list_files tool has enum (if present)
+        const listFilesTool = result.tools.find(
+          (t: any) => t.name === "list_files"
+        );
+        if (listFilesTool) {
+          expect(listFilesTool.inputSchema.properties.index_name.enum).toBeDefined();
+          expect(listFilesTool.inputSchema.properties.index_name.enum).toContain(
+            "test-key"
+          );
+        }
+
+        // Check read_file tool has enum (if present)
+        const readFileTool = result.tools.find((t: any) => t.name === "read_file");
+        if (readFileTool) {
+          expect(readFileTool.inputSchema.properties.index_name.enum).toBeDefined();
+          expect(readFileTool.inputSchema.properties.index_name.enum).toContain(
+            "test-key"
+          );
+        }
+      });
+
+      it("discovery mode does NOT include enum in tool schemas", async () => {
+        const mockState = createMockState();
+        const store = createMockStore(mockState);
+
+        const server = await createMCPServer({
+          store,
+          indexNames: ["test-key"],
+          discovery: true, // Discovery mode
+        });
+
+        // Get the ListToolsRequestSchema handler
+        const listToolsHandler = (server as any).requestHandlers.get(
+          ListToolsRequestSchema
+        );
+        const result = await listToolsHandler();
+
+        // Check search tool does NOT have enum
+        const searchTool = result.tools.find((t: any) => t.name === "search");
+        expect(searchTool.inputSchema.properties.index_name.enum).toBeUndefined();
+
+        // Check list_files tool does NOT have enum (if present)
+        const listFilesTool = result.tools.find(
+          (t: any) => t.name === "list_files"
+        );
+        if (listFilesTool) {
+          expect(listFilesTool.inputSchema.properties.index_name.enum).toBeUndefined();
+        }
+
+        // Check read_file tool does NOT have enum (if present)
+        const readFileTool = result.tools.find((t: any) => t.name === "read_file");
+        if (readFileTool) {
+          expect(readFileTool.inputSchema.properties.index_name.enum).toBeUndefined();
+        }
+      });
+
+      it("list_indexes tool is available in both fixed and discovery modes", async () => {
+        const mockState = createMockState();
+        const store = createMockStore(mockState);
+
+        // Test fixed mode
+        const fixedServer = await createMCPServer({
+          store,
+          indexNames: ["test-key"],
+          discovery: false,
+        });
+
+        const fixedListToolsHandler = (fixedServer as any).requestHandlers.get(
+          ListToolsRequestSchema
+        );
+        const fixedResult = await fixedListToolsHandler();
+        const fixedListIndexesTool = fixedResult.tools.find(
+          (t: any) => t.name === "list_indexes"
+        );
+        expect(fixedListIndexesTool).toBeDefined();
+
+        // Test discovery mode
+        const discoveryServer = await createMCPServer({
+          store,
+          indexNames: ["test-key"],
+          discovery: true,
+        });
+
+        const discoveryListToolsHandler = (discoveryServer as any).requestHandlers.get(
+          ListToolsRequestSchema
+        );
+        const discoveryResult = await discoveryListToolsHandler();
+        const discoveryListIndexesTool = discoveryResult.tools.find(
+          (t: any) => t.name === "list_indexes"
+        );
+        expect(discoveryListIndexesTool).toBeDefined();
+      });
+    });
+  }
+);
+