@pagopa/dx-mcpserver 0.1.4 → 0.1.5

package/dist/__tests__/http-endpoints.test.js

@@ -167,12 +167,6 @@ describe("HTTP Endpoints Integration Tests", () => {
             expect(data).toHaveProperty("query");
             expect(data).toHaveProperty("results");
             expect(Array.isArray(data.results)).toBe(true);
-            if (data.results.length > 0) {
-                const result = data.results[0];
-                expect(result).toHaveProperty("content");
-                expect(result).toHaveProperty("score");
-                expect(typeof result.score).toBe("number");
-            }
         });
         it("should use default number_of_results when not provided", async () => {
             const response = await fetch(`${baseUrl}/search`, {

package/dist/__tests__/index.test.js

@@ -1,5 +1,51 @@
 import { describe, expect, it, vi } from "vitest";
-import { mockCatalogEntry, mockPromptEntry, mockTool, } from "./__mocks__/handlers.js";
+import { z } from "zod";
+export const mockTool = {
+    annotations: {
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+        readOnlyHint: true,
+        title: "Test Tool",
+    },
+    description: "A test tool",
+    execute: vi.fn(async (args) => {
+        const parsedResult = z.object({ input: z.string() }).safeParse(args);
+        if (!parsedResult.success) {
+            return "Error: Invalid input";
+        }
+        return `Tool executed with: ${parsedResult.data.input}`;
+    }),
+    name: "TestTool",
+    parameters: z.object({
+        input: z.string().min(1, "Input cannot be empty"),
+    }),
+};
+export const mockCatalogEntry = {
+    category: "test",
+    enabled: true,
+    id: "test-prompt",
+    metadata: {
+        description: "A test prompt for unit testing",
+        title: "Test Prompt",
+    },
+    prompt: {
+        arguments: [
+            { description: "First argument", name: "arg1", required: true },
+            { description: "Second argument", name: "arg2", required: false },
+        ],
+        description: "A test prompt",
+        load: async (args) => `Prompt loaded with args: ${JSON.stringify(args)}`,
+        name: "TestPrompt",
+    },
+    tags: ["test"],
+};
+export const mockPromptEntry = {
+    catalogEntry: mockCatalogEntry,
+    prompt: {
+        load: vi.fn(async (args) => `Prompt loaded with args: ${JSON.stringify(args)}`),
+    },
+};
 describe("MCP Server Handlers", () => {
     describe("Tool Handler Validation", () => {
         it("should validate tool arguments against the Zod schema", async () => {
@@ -11,9 +57,7 @@ describe("MCP Server Handlers", () => {
             const invalidArgs = { input: "" };
             const invalidationResult = mockTool.parameters.safeParse(invalidArgs);
             expect(invalidationResult.success).toBe(false);
-            if (!invalidationResult.success) {
-                expect(invalidationResult.error.issues[0].message).toContain("cannot be empty");
-            }
+            expect(invalidationResult.error?.issues[0].message).toContain("cannot be empty");
         });
         it("should handle tool execution errors gracefully", async () => {
             const errorTool = {

package/dist/services/__tests__/bedrock.test.js

@@ -125,11 +125,8 @@ describe("queryKnowledgeBaseStructured - Basic Functionality", () => {
         const result = await queryKnowledgeBaseStructured("kbId", "query", mockClient);
         // resolveToWebsiteUrl should transform S3 URI to website URL
         expect(result[0].location).toBeDefined();
-        if (result[0].location?.webLocation?.url) {
-            expect(result[0].location.webLocation.url).toContain("https://");
-            // URL should have /index removed
-            expect(result[0].location.webLocation.url).not.toContain("/index");
-        }
+        expect(result[0].location?.webLocation?.url).toContain("https://");
+        expect(result[0].location?.webLocation?.url).not.toContain("/index");
     });
     it("should skip image content with warning logs", async () => {
         const mockClient = createMockBedrockClient(vi.fn().mockResolvedValue({

package/dist/services/bedrock.js

@@ -155,7 +155,7 @@ export function resolveToWebsiteUrl(location) {
         const match = location.s3Location.uri.match(/^s3:\/\/(?:[^/]+)\/(.+)$/);
         if (match) {
             const key = match[1];
-            let url = "";
+            let url;
             // Special case: llms-full.txt or llms.txt should be returned as https://dx.pagopa.it/<file>
             if (key === "llms-full.txt" || key === "llms.txt") {
                 url = `https://dx.pagopa.it/${key}`;

package/dist/tools/__tests__/QueryValidation.test.js

@@ -22,18 +22,14 @@ describe("Query Validation", () => {
             shortQueries.forEach((input) => {
                 const result = queryDocSchema.safeParse(input);
                 expect(result.success).toBe(false);
-                if (!result.success) {
-                    expect(result.error.errors[0].message).toBe("Query must be at least 3 characters");
-                }
+                expect(result.error?.errors[0].message).toBe("Query must be at least 3 characters");
             });
         });
         it("should reject queries exceeding 500 characters", () => {
             const longQuery = { query: "a".repeat(501) };
             const result = queryDocSchema.safeParse(longQuery);
             expect(result.success).toBe(false);
-            if (!result.success) {
-                expect(result.error.errors[0].message).toBe("Query must not exceed 500 characters");
-            }
+            expect(result.error?.errors[0].message).toBe("Query must not exceed 500 characters");
         });
         it("should reject missing query field", () => {
             const missingQuery = {};

package/dist/tools/__tests__/registry.test.js

@@ -45,23 +45,6 @@ describe("Tool Registry", () => {
                 expect(entry.tool.annotations.title).toBeTruthy();
             }
         });
-        it("should have boolean values for hint annotations when defined", () => {
-            for (const entry of toolDefinitions) {
-                const { annotations } = entry.tool;
-                if (annotations.readOnlyHint !== undefined) {
-                    expect(annotations.readOnlyHint).toBeTypeOf("boolean");
-                }
-                if (annotations.destructiveHint !== undefined) {
-                    expect(annotations.destructiveHint).toBeTypeOf("boolean");
-                }
-                if (annotations.idempotentHint !== undefined) {
-                    expect(annotations.idempotentHint).toBeTypeOf("boolean");
-                }
-                if (annotations.openWorldHint !== undefined) {
-                    expect(annotations.openWorldHint).toBeTypeOf("boolean");
-                }
-            }
-        });
     });
     describe("session requirements", () => {
         it("should mark documentation tool as not requiring session", () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pagopa/dx-mcpserver",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "type": "module",
   "description": "An MCP server that supports developers using DX tools.",
   "repository": {
@@ -28,17 +28,17 @@
     "axios": "^1.13.6",
     "zod": "^3.25.76",
     "@pagopa/azure-tracing": "^0.4.13",
-    "@pagopa/dx-mcpprompts": "^0.2.4"
+    "@pagopa/dx-mcpprompts": "^0.2.5"
   },
   "devDependencies": {
     "@types/node": "^22.19.15",
     "@vitest/coverage-v8": "^3.2.4",
-    "eslint": "^9.39.2",
+    "eslint": "^10.1.0",
     "prettier": "3.8.1",
     "tsx": "^4.21.0",
     "typescript": "~5.9.3",
     "vitest": "^3.2.4",
-    "@pagopa/eslint-config": "^5.1.2"
+    "@pagopa/eslint-config": "^6.0.0"
   },
   "scripts": {
     "start": "tsx src/cli.ts",

package/dist/__tests__/__mocks__/handlers.js

@@ -1,48 +0,0 @@
-import { vi } from "vitest";
-import { z } from "zod";
-export const mockTool = {
-    annotations: {
-        destructiveHint: false,
-        idempotentHint: true,
-        openWorldHint: true,
-        readOnlyHint: true,
-        title: "Test Tool",
-    },
-    description: "A test tool",
-    execute: vi.fn(async (args) => {
-        const parsedResult = z.object({ input: z.string() }).safeParse(args);
-        if (!parsedResult.success) {
-            return "Error: Invalid input";
-        }
-        return `Tool executed with: ${parsedResult.data.input}`;
-    }),
-    name: "TestTool",
-    parameters: z.object({
-        input: z.string().min(1, "Input cannot be empty"),
-    }),
-};
-export const mockCatalogEntry = {
-    category: "test",
-    enabled: true,
-    id: "test-prompt",
-    metadata: {
-        description: "A test prompt for unit testing",
-        title: "Test Prompt",
-    },
-    prompt: {
-        arguments: [
-            { description: "First argument", name: "arg1", required: true },
-            { description: "Second argument", name: "arg2", required: false },
-        ],
-        description: "A test prompt",
-        load: async (args) => `Prompt loaded with args: ${JSON.stringify(args)}`,
-        name: "TestPrompt",
-    },
-    tags: ["test"],
-};
-export const mockPromptEntry = {
-    catalogEntry: mockCatalogEntry,
-    prompt: {
-        load: vi.fn(async (args) => `Prompt loaded with args: ${JSON.stringify(args)}`),
-    },
-};