postgresai 0.14.0 → 0.15.0-dev.10

package/test/mcp-server.test.ts

@@ -75,8 +75,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: null,
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       const response = await handleToolCall(createRequest("list_issues"));
@@ -91,8 +93,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: null,
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       // Mock fetch to verify API key is used
@@ -119,8 +123,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "config-api-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       let capturedHeaders: Record<string, string> | undefined;
@@ -148,8 +154,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: null,
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       let capturedHeaders: Record<string, string> | undefined;
@@ -182,8 +190,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       globalThis.fetch = mock(() =>
@@ -209,8 +219,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       globalThis.fetch = mock(() =>
@@ -236,8 +248,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       const response = await handleToolCall(createRequest("view_issue", { issue_id: "" }));
@@ -252,8 +266,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       const response = await handleToolCall(createRequest("view_issue", { issue_id: "   " }));
@@ -268,8 +284,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       // Return null for issue (not found)
@@ -297,8 +315,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       let callCount = 0;
@@ -337,8 +357,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       const response = await handleToolCall(
@@ -355,8 +377,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       const response = await handleToolCall(
@@ -373,8 +397,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       let capturedBody: string | undefined;
@@ -406,8 +432,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       let capturedBody: string | undefined;
@@ -443,8 +471,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: 1,
         defaultProject: null,
+        projectName: null,
       });
 
       const response = await handleToolCall(createRequest("create_issue", { title: "" }));
@@ -459,8 +489,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: 1,
         defaultProject: null,
+        projectName: null,
       });
 
       const response = await handleToolCall(createRequest("create_issue", { title: "   " }));
@@ -475,8 +507,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       const response = await handleToolCall(createRequest("create_issue", { title: "Test Issue" }));
@@ -491,8 +525,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: 42,
         defaultProject: null,
+        projectName: null,
       });
 
       let capturedBody: string | undefined;
@@ -519,8 +555,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: 1,
         defaultProject: null,
+        projectName: null,
       });
 
       let capturedBody: string | undefined;
@@ -553,8 +591,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       let capturedBody: string | undefined;
@@ -596,8 +636,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       const response = await handleToolCall(
@@ -614,8 +656,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       const response = await handleToolCall(createRequest("update_issue", { issue_id: "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa" }));
@@ -630,8 +674,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       const response = await handleToolCall(
@@ -648,8 +694,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       const response = await handleToolCall(
@@ -666,8 +714,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       let capturedBody: string | undefined;
@@ -701,8 +751,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       globalThis.fetch = mock(() =>
@@ -727,8 +779,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       let capturedBody: string | undefined;
@@ -758,8 +812,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       let capturedBody: string | undefined;
@@ -789,8 +845,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       let capturedBody: string | undefined;
@@ -822,8 +880,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       const response = await handleToolCall(
@@ -840,8 +900,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       const response = await handleToolCall(
@@ -858,8 +920,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       let capturedBody: string | undefined;
@@ -891,8 +955,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       globalThis.fetch = mock(() =>
@@ -924,8 +990,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       const response = await handleToolCall(createRequest("view_action_item", {}));
@@ -940,8 +1008,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       const response = await handleToolCall(createRequest("view_action_item", { action_item_id: "" }));
@@ -956,8 +1026,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       const response = await handleToolCall(createRequest("view_action_item", { action_item_ids: [] }));
@@ -972,8 +1044,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       const response = await handleToolCall(createRequest("view_action_item", { action_item_id: "invalid-id-format" }));
@@ -988,8 +1062,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       globalThis.fetch = mock(() =>
@@ -1025,8 +1101,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       globalThis.fetch = mock(() =>
@@ -1059,8 +1137,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       let capturedUrl: string | undefined;
@@ -1093,8 +1173,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       const response = await handleToolCall(createRequest("list_action_items", { issue_id: "" }));
@@ -1109,8 +1191,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       const response = await handleToolCall(createRequest("list_action_items", { issue_id: "   " }));
@@ -1130,8 +1214,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       globalThis.fetch = mock(() =>
@@ -1159,8 +1245,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       const response = await handleToolCall(
@@ -1177,8 +1265,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       const response = await handleToolCall(
@@ -1195,8 +1285,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       let capturedBody: string | undefined;
@@ -1230,8 +1322,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       let capturedBody: string | undefined;
@@ -1271,8 +1365,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       let capturedBody: string | undefined;
@@ -1308,8 +1404,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       const response = await handleToolCall(
@@ -1326,8 +1424,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       const response = await handleToolCall(
@@ -1344,8 +1444,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       const response = await handleToolCall(
@@ -1362,8 +1464,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       let capturedBody: string | undefined;
@@ -1394,8 +1498,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       let capturedBody: string | undefined;
@@ -1425,8 +1531,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       let capturedBody: string | undefined;
@@ -1463,8 +1571,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: null,
         defaultProject: null,
+        projectName: null,
       });
 
       const response = await handleToolCall(createRequest("nonexistent_tool"));
@@ -1476,13 +1586,417 @@ describe("MCP Server", () => {
     });
   });
 
+  describe("list_reports tool", () => {
+    test("successfully returns reports list as JSON", async () => {
+      const mockReports = [
+        { id: 1, org_id: 1, org_name: "TestOrg", project_id: 10, project_name: "prod-db", status: "completed" },
+      ];
+
+      const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
+        apiKey: "test-key",
+        baseUrl: null,
+        storageBaseUrl: null,
+        orgId: null,
+        defaultProject: null,
+        projectName: null,
+      });
+
+      globalThis.fetch = mock(() =>
+        Promise.resolve(
+          new Response(JSON.stringify(mockReports), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+          })
+        )
+      ) as unknown as typeof fetch;
+
+      const response = await handleToolCall(createRequest("list_reports"));
+
+      expect(response.isError).toBeUndefined();
+      const parsed = JSON.parse(getResponseText(response));
+      expect(parsed).toHaveLength(1);
+      expect(parsed[0].status).toBe("completed");
+
+      readConfigSpy.mockRestore();
+    });
+
+    test("passes filters to API", async () => {
+      const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
+        apiKey: "test-key",
+        baseUrl: null,
+        storageBaseUrl: null,
+        orgId: null,
+        defaultProject: null,
+        projectName: null,
+      });
+
+      let capturedUrl: string | undefined;
+      globalThis.fetch = mock((url: string) => {
+        capturedUrl = url;
+        return Promise.resolve(
+          new Response(JSON.stringify([]), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+          })
+        );
+      }) as unknown as typeof fetch;
+
+      await handleToolCall(createRequest("list_reports", {
+        project_id: 5,
+        status: "completed",
+        limit: 10,
+      }));
+
+      expect(capturedUrl).toContain("project_id=eq.5");
+      expect(capturedUrl).toContain("status=eq.completed");
+      expect(capturedUrl).toContain("limit=10");
+
+      readConfigSpy.mockRestore();
+    });
+
+    test("handles API errors gracefully", async () => {
+      const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
+        apiKey: "test-key",
+        baseUrl: null,
+        storageBaseUrl: null,
+        orgId: null,
+        defaultProject: null,
+        projectName: null,
+      });
+
+      globalThis.fetch = mock(() =>
+        Promise.resolve(
+          new Response('{"message": "Unauthorized"}', {
+            status: 401,
+            headers: { "Content-Type": "application/json" },
+          })
+        )
+      ) as unknown as typeof fetch;
+
+      const response = await handleToolCall(createRequest("list_reports"));
+
+      expect(response.isError).toBe(true);
+      expect(getResponseText(response)).toContain("401");
+
+      readConfigSpy.mockRestore();
+    });
+
+    test("passes before_date to API as created_at filter", async () => {
+      const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
+        apiKey: "test-key",
+        baseUrl: null,
+        storageBaseUrl: null,
+        orgId: null,
+        defaultProject: null,
+        projectName: null,
+      });
+
+      let capturedUrl: string | undefined;
+      globalThis.fetch = mock((url: string) => {
+        capturedUrl = url;
+        return Promise.resolve(
+          new Response(JSON.stringify([]), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+          })
+        );
+      }) as unknown as typeof fetch;
+
+      await handleToolCall(createRequest("list_reports", {
+        before_date: "2025-01-15",
+      }));
+
+      expect(capturedUrl).toContain("created_at=lt.2025-01-15");
+
+      readConfigSpy.mockRestore();
+    });
+
+    test("fetches all reports when all=true", async () => {
+      const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
+        apiKey: "test-key",
+        baseUrl: null,
+        storageBaseUrl: null,
+        orgId: null,
+        defaultProject: null,
+        projectName: null,
+      });
+
+      const mockReports = [
+        { id: 10, org_id: 1, org_name: "O", project_id: 1, project_name: "P", status: "completed" },
+      ];
+
+      globalThis.fetch = mock(() =>
+        Promise.resolve(
+          new Response(JSON.stringify(mockReports), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+          })
+        )
+      ) as unknown as typeof fetch;
+
+      const response = await handleToolCall(createRequest("list_reports", {
+        all: true,
+      }));
+
+      expect(response.isError).toBeUndefined();
+      const parsed = JSON.parse(getResponseText(response));
+      expect(parsed).toHaveLength(1);
+      expect(parsed[0].id).toBe(10);
+
+      readConfigSpy.mockRestore();
+    });
+  });
+
+  describe("list_report_files tool", () => {
+    test("returns error when neither report_id nor check_id is provided", async () => {
+      const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
+        apiKey: "test-key",
+        baseUrl: null,
+        storageBaseUrl: null,
+        orgId: null,
+        defaultProject: null,
+        projectName: null,
+      });
+
+      const response = await handleToolCall(createRequest("list_report_files", {}));
+
+      expect(response.isError).toBe(true);
+      expect(getResponseText(response)).toContain("Either report_id or check_id is required");
+
+      readConfigSpy.mockRestore();
+    });
+
+    test("works with only check_id (no report_id)", async () => {
+      const mockFiles = [
+        { id: 100, checkup_report_id: 1, filename: "H002.md", check_id: "H002", type: "md" },
+      ];
+
+      const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
+        apiKey: "test-key",
+        baseUrl: null,
+        storageBaseUrl: null,
+        orgId: null,
+        defaultProject: null,
+        projectName: null,
+      });
+
+      let capturedUrl: string | undefined;
+      globalThis.fetch = mock((url: string) => {
+        capturedUrl = url;
+        return Promise.resolve(
+          new Response(JSON.stringify(mockFiles), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+          })
+        );
+      }) as unknown as typeof fetch;
+
+      const response = await handleToolCall(createRequest("list_report_files", {
+        check_id: "H002",
+      }));
+
+      expect(response.isError).toBeUndefined();
+      const parsed = JSON.parse(getResponseText(response));
+      expect(parsed[0].filename).toBe("H002.md");
+      expect(capturedUrl).toContain("check_id=eq.H002");
+      expect(capturedUrl).not.toContain("checkup_report_id");
+
+      readConfigSpy.mockRestore();
+    });
+
+    test("successfully returns report files", async () => {
+      const mockFiles = [
+        { id: 100, checkup_report_id: 1, filename: "H002.md", check_id: "H002", type: "md" },
+      ];
+
+      const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
+        apiKey: "test-key",
+        baseUrl: null,
+        storageBaseUrl: null,
+        orgId: null,
+        defaultProject: null,
+        projectName: null,
+      });
+
+      let capturedUrl: string | undefined;
+      globalThis.fetch = mock((url: string) => {
+        capturedUrl = url;
+        return Promise.resolve(
+          new Response(JSON.stringify(mockFiles), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+          })
+        );
+      }) as unknown as typeof fetch;
+
+      const response = await handleToolCall(createRequest("list_report_files", {
+        report_id: 1,
+        type: "md",
+        check_id: "H002",
+      }));
+
+      expect(response.isError).toBeUndefined();
+      const parsed = JSON.parse(getResponseText(response));
+      expect(parsed[0].filename).toBe("H002.md");
+      expect(capturedUrl).toContain("checkup_report_id=eq.1");
+      expect(capturedUrl).toContain("type=eq.md");
+      expect(capturedUrl).toContain("check_id=eq.H002");
+
+      readConfigSpy.mockRestore();
+    });
+  });
+
+  describe("get_report_data tool", () => {
+    test("returns error when neither report_id nor check_id is provided", async () => {
+      const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
+        apiKey: "test-key",
+        baseUrl: null,
+        storageBaseUrl: null,
+        orgId: null,
+        defaultProject: null,
+        projectName: null,
+      });
+
+      const response = await handleToolCall(createRequest("get_report_data", {}));
+
+      expect(response.isError).toBe(true);
+      expect(getResponseText(response)).toContain("Either report_id or check_id is required");
+
+      readConfigSpy.mockRestore();
+    });
+
+    test("works with only check_id (no report_id)", async () => {
+      const mockData = [
+        {
+          id: 100,
+          checkup_report_id: 1,
+          filename: "H002.md",
+          check_id: "H002",
+          type: "md",
+          data: "# H002\n\nUnused indexes found.",
+        },
+      ];
+
+      const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
+        apiKey: "test-key",
+        baseUrl: null,
+        storageBaseUrl: null,
+        orgId: null,
+        defaultProject: null,
+        projectName: null,
+      });
+
+      let capturedUrl: string | undefined;
+      globalThis.fetch = mock((url: string) => {
+        capturedUrl = url;
+        return Promise.resolve(
+          new Response(JSON.stringify(mockData), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+          })
+        );
+      }) as unknown as typeof fetch;
+
+      const response = await handleToolCall(createRequest("get_report_data", {
+        check_id: "H002",
+      }));
+
+      expect(response.isError).toBeUndefined();
+      const parsed = JSON.parse(getResponseText(response));
+      expect(parsed[0].data).toContain("# H002");
+      expect(capturedUrl).toContain("check_id=eq.H002");
+      expect(capturedUrl).not.toContain("checkup_report_id");
+
+      readConfigSpy.mockRestore();
+    });
+
+    test("successfully returns report data with content", async () => {
+      const mockData = [
+        {
+          id: 100,
+          checkup_report_id: 1,
+          filename: "H002.md",
+          check_id: "H002",
+          type: "md",
+          data: "# H002\n\nUnused indexes found.",
+        },
+      ];
+
+      const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
+        apiKey: "test-key",
+        baseUrl: null,
+        storageBaseUrl: null,
+        orgId: null,
+        defaultProject: null,
+        projectName: null,
+      });
+
+      globalThis.fetch = mock(() =>
+        Promise.resolve(
+          new Response(JSON.stringify(mockData), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+          })
+        )
+      ) as unknown as typeof fetch;
+
+      const response = await handleToolCall(createRequest("get_report_data", {
+        report_id: 1,
+        type: "md",
+        check_id: "H002",
+      }));
+
+      expect(response.isError).toBeUndefined();
+      const parsed = JSON.parse(getResponseText(response));
+      expect(parsed[0].data).toContain("# H002");
+
+      readConfigSpy.mockRestore();
+    });
+
+    test("passes filters to API", async () => {
+      const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
+        apiKey: "test-key",
+        baseUrl: null,
+        storageBaseUrl: null,
+        orgId: null,
+        defaultProject: null,
+        projectName: null,
+      });
+
+      let capturedUrl: string | undefined;
+      globalThis.fetch = mock((url: string) => {
+        capturedUrl = url;
+        return Promise.resolve(
+          new Response(JSON.stringify([]), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+          })
+        );
+      }) as unknown as typeof fetch;
+
+      await handleToolCall(createRequest("get_report_data", {
+        report_id: 42,
+        type: "json",
+        check_id: "F004",
+      }));
+
+      expect(capturedUrl).toContain("checkup_report_id=eq.42");
+      expect(capturedUrl).toContain("type=eq.json");
+      expect(capturedUrl).toContain("check_id=eq.F004");
+
+      readConfigSpy.mockRestore();
+    });
+  });
+
   describe("error propagation", () => {
     test("propagates API errors through MCP layer", async () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: 1,
         defaultProject: null,
+        projectName: null,
       });
 
       globalThis.fetch = mock(() =>
@@ -1508,8 +2022,10 @@ describe("MCP Server", () => {
       const readConfigSpy = spyOn(config, "readConfig").mockReturnValue({
         apiKey: "test-key",
         baseUrl: null,
+        storageBaseUrl: null,
         orgId: 1,
         defaultProject: null,
+        projectName: null,
       });
 
       globalThis.fetch = mock(() => Promise.reject(new Error("Network error"))) as unknown as typeof fetch;