@uuv/mcp-server 0.1.3 → 0.2.0

package/dist/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [0.1.3](https://github.com/e2e-test-quest/uuv/compare/mcp-server-v0.1.2...mcp-server-v0.1.3) (2025-11-21)
+
+
+### Bug Fixes
+
+* **mcp-server:** add requirements and claude code config ([a942847](https://github.com/e2e-test-quest/uuv/commit/a942847afe5c0af96adffdd7ec1d56852c53a119))
+
 ## [0.1.2](https://github.com/e2e-test-quest/uuv/compare/mcp-server-v0.1.1...mcp-server-v0.1.2) (2025-11-20)
 
 

package/dist/lib/mcp-server-factory.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function createUUVServer(): McpServer;

package/dist/lib/mcp-server-factory.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUUVServer = createUUVServer;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const zod_1 = require("zod");
+const sentence_service_1 = require("./services/sentence.service");
+const prompt_retriever_service_1 = require("./services/prompt-retriever.service");
+const dictionary_1 = require("@uuv/dictionary");
+const expect_service_1 = require("./services/expect.service");
+function handleElementTestGeneration(input) {
+    let result;
+    const service = (0, expect_service_1.getElementService)(input.serviceType);
+    if (input.accessibleName && input.accessibleRole) {
+        result = service.generateTestForElement(input);
+    }
+    else if (input.domSelector) {
+        result = service.generateTestForElement(input);
+    }
+    else {
+        throw new Error("You must provide either (accessibleRole AND accessibleName) or domSelector");
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: result,
+            },
+        ],
+    };
+}
+function createUUVServer() {
+    const server = new mcp_js_1.McpServer({
+        name: "uuv-mcp-server",
+        version: "0.0.1-beta",
+    });
+    const FindElementInputSchema = {
+        baseUrl: zod_1.z.string().describe("The base URL of the page where the element is located."),
+        accessibleName: zod_1.z.string().optional().describe("Accessible name of the element"),
+        accessibleRole: zod_1.z.string().optional().describe("Accessible role of the element"),
+        domSelector: zod_1.z.string().optional().describe("Dom selector of the element"),
+    };
+    server.registerTool("retrieve_prompt", {
+        title: "Retrieve uuv prompt",
+        description: "Retrieve a uuv prompt template for a coding agent based on a prompt name and arguments.",
+        inputSchema: {
+            promptName: zod_1.z.enum([
+                prompt_retriever_service_1.UUV_PROMPT.GENERATE_TEST_EXPECT_TABLE,
+                prompt_retriever_service_1.UUV_PROMPT.GENERATE_TEST_EXPECT_ELEMENT,
+                prompt_retriever_service_1.UUV_PROMPT.GENERATE_TEST_CLICK_ELEMENT,
+            ]),
+            baseUrl: zod_1.z.string().describe("The base URL of the page"),
+            // generate_test_* Fields
+            accessibleName: zod_1.z.string().optional().describe("Accessible name (required for generate_role_and_name)"),
+            accessibleRole: zod_1.z.string().optional().describe("Accessible role (required for generate_role_and_name)"),
+            domSelector: zod_1.z.string().optional().describe("Dom selector of the element"),
+        },
+    }, async ({ ...args }) => {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: prompt_retriever_service_1.PromptRetrieverService.retrievePrompt(args),
+                },
+            ],
+        };
+    });
+    server.registerTool("available_sentences", {
+        title: "List Available UUV Sentences",
+        description: 
+        // eslint-disable-next-line max-len
+        "List all available UUV test sentences/phrases in Gherkin format. Use this when the user asks about UUV syntax, available commands, what sentences/phrases are available for testing, or needs help with UUV sentence structure. Can be filtered by category (given/when/then) or ARIA role (button, textbox, etc.) to show specific test actions.",
+        inputSchema: {
+            category: zod_1.z
+                .enum(["general", "keyboard", "click", "contains", "type", "checkable"])
+                .optional()
+                .describe("Filters sentences based on the action type"),
+            role: zod_1.z.string().optional().describe("Filters sentences related to an accessible role"),
+        },
+    }, async ({ category, role }) => {
+        const sentenceService = new sentence_service_1.SentenceService((0, dictionary_1.getDefinedDictionary)("en"));
+        const allSentences = sentenceService.searchSentences({ category, role });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(allSentences, null, 2),
+                },
+            ],
+        };
+    });
+    server.registerTool("generate_test_expect_element", {
+        title: "Generate test that expects of html element with role and name",
+        description: 
+        // eslint-disable-next-line max-len
+        "Generate a complete UUV test scenario (Gherkin format) to verify the presence of an element with specified accessible name and role or domSelector. Use this when the user asks to create/write/generate a UUV scenario or test for checking element visibility. DON'T USE IF ACCESSIBLE ROLE IS grid, treegrid, table, or form",
+        inputSchema: FindElementInputSchema,
+    }, ({ baseUrl, accessibleName, accessibleRole, domSelector }) => {
+        if (accessibleRole === "table" || accessibleRole === "grid" || accessibleRole === "treegrid") {
+            throw new Error("For role 'table/grid/treegrid', you must use generate_test_expect_table tool.");
+        }
+        return handleElementTestGeneration({ serviceType: expect_service_1.ElementServiceType.EXPECT, baseUrl, accessibleName, accessibleRole, domSelector });
+    });
+    server.registerTool("generate_test_click_element", {
+        title: "Generate test that clicks on html element with role and name",
+        description: 
+        // eslint-disable-next-line max-len
+        "Generate a complete UUV test scenario (Gherkin format) to click on an element with specified accessible name and role or domSelector. Use this when the user asks to create/write/generate a UUV scenario or test for checking element visibility. DON'T USE IF ACCESSIBLE ROLE IS grid, treegrid, table, or form",
+        inputSchema: FindElementInputSchema,
+    }, async ({ baseUrl, accessibleName, accessibleRole, domSelector }) => {
+        return handleElementTestGeneration({ serviceType: expect_service_1.ElementServiceType.CLICK, baseUrl, accessibleName, accessibleRole, domSelector });
+    });
+    server.registerTool("generate_test_within_element", {
+        title: "Generate test that focus within an html element with role and name",
+        description: 
+        // eslint-disable-next-line max-len
+        "Generate a complete UUV test scenario (Gherkin format) that focus within an html element with specified accessible name and role or domSelector. Use this when the user asks to create/write/generate a UUV scenario or test for checking element visibility. DON'T USE IF ACCESSIBLE ROLE IS grid, treegrid, table, or form",
+        inputSchema: FindElementInputSchema,
+    }, async ({ baseUrl, accessibleName, accessibleRole, domSelector }) => {
+        return handleElementTestGeneration({ serviceType: expect_service_1.ElementServiceType.WITHIN, baseUrl, accessibleName, accessibleRole, domSelector });
+    });
+    server.registerTool("generate_test_type_element", {
+        title: "Generate test that types a value into html element with role and name",
+        description: 
+        // eslint-disable-next-line max-len
+        "Generate a complete UUV test scenario (Gherkin format) that types a value into an html element with specified accessible name and role or domSelector. Use this when the user asks to create/write/generate a UUV scenario or test for checking element visibility. DON'T USE IF ACCESSIBLE ROLE IS grid, treegrid, table, or form",
+        inputSchema: FindElementInputSchema,
+    }, async ({ baseUrl, accessibleName, accessibleRole, domSelector }) => {
+        return handleElementTestGeneration({ serviceType: expect_service_1.ElementServiceType.TYPE, baseUrl, accessibleName, accessibleRole, domSelector });
+    });
+    server.registerTool("generate_test_expect_table", {
+        title: "Generate test for html table or grid or treeGrid",
+        description: 
+        // eslint-disable-next-line max-len
+        "Generate a complete UUV test scenario (Gherkin format) to verify the presence and the content of html table, grid or treegrid given innerHtml. ONLY USE IF ACCESSIBLE ROLE IS grid, treegrid, table, or form",
+        inputSchema: {
+            baseUrl: zod_1.z.string().describe("The base URL of the page where the table/grid/treegrid is located."),
+            innerHtmlFilePath: zod_1.z.string().describe("File path containing the raw innerHTML content of the table, grid, or treegrid element"),
+        },
+    }, async ({ baseUrl, innerHtmlFilePath }) => {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: await expect_service_1.ExpectTableService.generateExpectForTable(baseUrl, innerHtmlFilePath),
+                },
+            ],
+        };
+    });
+    return server;
+}

package/dist/lib/mcp-server.js

@@ -1,102 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
-const zod_1 = require("zod");
-const sentence_service_1 = require("./services/sentence.service");
-const prompt_retriever_service_1 = require("./services/prompt-retriever.service");
-const expect_service_1 = require("./services/expect.service");
-const dictionary_1 = require("@uuv/dictionary");
-// Create an MCP server
-const server = new mcp_js_1.McpServer({
-    name: "uuv-mcp-server",
-    version: "0.0.1-beta",
-});
-server.registerTool("retrieve_prompt", {
-    title: "Retrieve uuv prompt",
-    description: "Retrieve a uuv prompt template for a coding agent based on a prompt name and arguments.",
-    inputSchema: {
-        promptName: zod_1.z.enum(["generate_table", "generate_role_and_name"]),
-        baseUrl: zod_1.z.string().describe("The base URL of the page"),
-        // generate_role_and_name Fields
-        accessibleName: zod_1.z.string().optional().describe("Accessible name (required for generate_role_and_name)"),
-        accessibleRole: zod_1.z.string().optional().describe("Accessible role (required for generate_role_and_name)")
-    },
-}, async ({ ...args }) => {
-    return {
-        content: [
-            {
-                type: "text",
-                text: prompt_retriever_service_1.PromptRetrieverService.retrievePrompt(args),
-            },
-        ],
-    };
-});
-server.registerTool("available_sentences", {
-    title: "List Available UUV Sentences",
-    description: 
-    // eslint-disable-next-line max-len
-    "List all available UUV test sentences/phrases in Gherkin format. Use this when the user asks about UUV syntax, available commands, what sentences/phrases are available for testing, or needs help with UUV sentence structure. Can be filtered by category (given/when/then) or ARIA role (button, textbox, etc.) to show specific test actions.",
-    inputSchema: {
-        category: zod_1.z
-            .enum(["general", "keyboard", "click", "contains", "type", "checkable"])
-            .optional()
-            .describe("Filters sentences based on the action type"),
-        role: zod_1.z.string().optional().describe("Filters sentences related to an accessible role"),
-    },
-}, async ({ category, role }) => {
-    const sentenceService = new sentence_service_1.SentenceService((0, dictionary_1.getDefinedDictionary)("en"));
-    const allSentences = sentenceService.searchSentences({ category, role });
-    return {
-        content: [
-            {
-                type: "text",
-                text: JSON.stringify(allSentences, null, 2),
-            },
-        ],
-    };
-});
-server.registerTool("generate_role_and_name", {
-    title: "Generate with role and name",
-    description: 
-    // eslint-disable-next-line max-len
-    "Generate a complete UUV test scenario (Gherkin format) to verify the presence of an element with specified accessible name and role. Use this when the user asks to create/write/generate a UUV scenario or test for checking element visibility. DON'T USE IF ACCESSIBLE ROLE IS grid, treegrid, table, or form",
-    inputSchema: {
-        baseUrl: zod_1.z.string().describe("The base URL of the page where the element is located."),
-        accessibleName: zod_1.z.string().describe("Accessible name of the element"),
-        accessibleRole: zod_1.z.string().describe("Accessible role of the element"),
-    },
-}, async ({ baseUrl, accessibleName, accessibleRole }) => {
-    if (accessibleRole === "table" || accessibleRole === "grid" || accessibleRole === "treegrid") {
-        throw new Error("For role 'table/grid/treegrid', you must use generateExpectForTable.");
-    }
-    return {
-        content: [
-            {
-                type: "text",
-                text: expect_service_1.ExpectService.generateForAccessibleNameAndRole(baseUrl, accessibleName, accessibleRole),
-            },
-        ],
-    };
-});
-server.registerTool("generate_table", {
-    title: "Generate test for html table or grid or treeGrid",
-    description: 
-    // eslint-disable-next-line max-len
-    "Generate a complete UUV test scenario (Gherkin format) to verify the presence and the content of html table, grid or treegrid given innerHtml. ONLY USE IF ACCESSIBLE ROLE IS grid, treegrid, table, or form",
-    inputSchema: {
-        baseUrl: zod_1.z.string().describe("The base URL of the page where the table/grid/treegrid is located."),
-        innerHtmlFilePath: zod_1.z.string().describe("File path containing the raw innerHTML content of the table, grid, or treegrid element"),
-    },
-}, async ({ baseUrl, innerHtmlFilePath }) => {
-    return {
-        content: [
-            {
-                type: "text",
-                text: await expect_service_1.ExpectService.generateForTable(baseUrl, innerHtmlFilePath),
-            },
-        ],
-    };
-});
+const mcp_server_factory_1 = require("./mcp-server-factory");
+const server = (0, mcp_server_factory_1.createUUVServer)();
 const transport = new stdio_js_1.StdioServerTransport();
 server.connect(transport);

package/dist/lib/services/element/abstract-element.service.d.ts

@@ -0,0 +1,6 @@
+import { FindElementByDomSelector, FindElementByRoleAndName } from "../expect.service";
+export declare abstract class AbstractElementService {
+    generateTestForElement(input: FindElementByRoleAndName | FindElementByDomSelector): string;
+    protected abstract generateTestForAccessibleNameAndRole(input: FindElementByRoleAndName): string;
+    protected abstract generateTestForDomSelector(input: FindElementByDomSelector): string;
+}

package/dist/lib/services/element/abstract-element.service.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractElementService = void 0;
+class AbstractElementService {
+    generateTestForElement(input) {
+        if (input.accessibleName && input.accessibleRole) {
+            return this.generateTestForAccessibleNameAndRole(input);
+        }
+        else if (input.domSelector) {
+            return this.generateTestForDomSelector(input);
+        }
+        return "";
+    }
+}
+exports.AbstractElementService = AbstractElementService;

package/dist/lib/services/element/click-element.service.d.ts

@@ -0,0 +1,6 @@
+import { AbstractElementService } from "./abstract-element.service";
+import { FindElementByDomSelector, FindElementByRoleAndName } from "../expect.service";
+export declare class ClickElementService extends AbstractElementService {
+    generateTestForAccessibleNameAndRole(input: FindElementByRoleAndName): string;
+    generateTestForDomSelector(input: FindElementByDomSelector): string;
+}

package/dist/lib/services/element/click-element.service.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClickElementService = void 0;
+const abstract_element_service_1 = require("./abstract-element.service");
+const assistant_1 = require("@uuv/assistant");
+class ClickElementService extends abstract_element_service_1.AbstractElementService {
+    generateTestForAccessibleNameAndRole(input) {
+        const translator = new assistant_1.ClickTranslator();
+        const result = translator.getSentenceFromAccessibleRoleAndName(input.accessibleRole, input.accessibleName);
+        return (0, assistant_1.buildResultingScript)("Your amazing feature name", "Action - An action", result.sentences, input.baseUrl);
+    }
+    generateTestForDomSelector(input) {
+        const translator = new assistant_1.ClickTranslator();
+        const result = translator.getSentenceFromDomSelector(input.domSelector);
+        return (0, assistant_1.buildResultingScript)("Your amazing feature name", "Action - An action", result.sentences, input.baseUrl);
+    }
+}
+exports.ClickElementService = ClickElementService;

package/dist/lib/services/element/expect-element.service.d.ts

@@ -0,0 +1,6 @@
+import { AbstractElementService } from "./abstract-element.service";
+import { FindElementByDomSelector, FindElementByRoleAndName } from "../expect.service";
+export declare class ExpectElementService extends AbstractElementService {
+    generateTestForAccessibleNameAndRole(input: FindElementByRoleAndName): string;
+    generateTestForDomSelector(input: FindElementByDomSelector): string;
+}

package/dist/lib/services/element/expect-element.service.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpectElementService = void 0;
+const abstract_element_service_1 = require("./abstract-element.service");
+const assistant_1 = require("@uuv/assistant");
+class ExpectElementService extends abstract_element_service_1.AbstractElementService {
+    generateTestForAccessibleNameAndRole(input) {
+        const translator = new assistant_1.ExpectTranslator();
+        const result = translator.getSentenceFromAccessibleRoleAndName(input.accessibleRole, input.accessibleName);
+        return (0, assistant_1.buildResultingScript)("Your amazing feature name", "Action - An action", result.sentences, input.baseUrl);
+    }
+    generateTestForDomSelector(input) {
+        const translator = new assistant_1.ExpectTranslator();
+        const result = translator.getSentenceFromDomSelector(input.domSelector);
+        return (0, assistant_1.buildResultingScript)("Your amazing feature name", "Action - An action", result.sentences, input.baseUrl);
+    }
+}
+exports.ExpectElementService = ExpectElementService;

package/dist/lib/services/element/type-element.service.d.ts

@@ -0,0 +1,6 @@
+import { AbstractElementService } from "./abstract-element.service";
+import { FindElementByDomSelector, FindElementByRoleAndName } from "../expect.service";
+export declare class TypeElementService extends AbstractElementService {
+    generateTestForAccessibleNameAndRole(input: FindElementByRoleAndName): string;
+    generateTestForDomSelector(input: FindElementByDomSelector): string;
+}

package/dist/lib/services/element/type-element.service.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeElementService = void 0;
+const abstract_element_service_1 = require("./abstract-element.service");
+const assistant_1 = require("@uuv/assistant");
+class TypeElementService extends abstract_element_service_1.AbstractElementService {
+    generateTestForAccessibleNameAndRole(input) {
+        const translator = new assistant_1.TypeTranslator();
+        translator.useValueAsMockData = false;
+        const result = translator.getSentenceFromAccessibleRoleAndName(input.accessibleRole, input.accessibleName);
+        return (0, assistant_1.buildResultingScript)("Your amazing feature name", "Action - An action", result.sentences, input.baseUrl);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    generateTestForDomSelector(input) {
+        throw Error("Not implemented yet");
+    }
+}
+exports.TypeElementService = TypeElementService;

package/dist/lib/services/element/within-element.service.d.ts

@@ -0,0 +1,6 @@
+import { AbstractElementService } from "./abstract-element.service";
+import { FindElementByDomSelector, FindElementByRoleAndName } from "../expect.service";
+export declare class WithinElementService extends AbstractElementService {
+    generateTestForAccessibleNameAndRole(input: FindElementByRoleAndName): string;
+    generateTestForDomSelector(input: FindElementByDomSelector): string;
+}

package/dist/lib/services/element/within-element.service.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WithinElementService = void 0;
+const abstract_element_service_1 = require("./abstract-element.service");
+const assistant_1 = require("@uuv/assistant");
+class WithinElementService extends abstract_element_service_1.AbstractElementService {
+    generateTestForAccessibleNameAndRole(input) {
+        const translator = new assistant_1.WithinTranslator();
+        const result = translator.getSentenceFromAccessibleRoleAndName(input.accessibleRole, input.accessibleName);
+        return (0, assistant_1.buildResultingScript)("Your amazing feature name", "Action - An action", result.sentences, input.baseUrl);
+    }
+    generateTestForDomSelector(input) {
+        const translator = new assistant_1.WithinTranslator();
+        const result = translator.getSentenceFromDomSelector(input.domSelector);
+        return (0, assistant_1.buildResultingScript)("Your amazing feature name", "Action - An action", result.sentences, input.baseUrl);
+    }
+}
+exports.WithinElementService = WithinElementService;

package/dist/lib/services/expect.service.d.ts

@@ -1,4 +1,21 @@
-export declare class ExpectService {
-    static generateForAccessibleNameAndRole(baseUrl: string, accessibleName: string, accessibleRole: string): string;
-    static generateForTable(baseUrl: string, innerHtmlFilePath: string): Promise<string>;
+import { AbstractElementService } from "./element/abstract-element.service";
+export type FindElementByRoleAndName = {
+    baseUrl: string;
+    accessibleName: string;
+    accessibleRole: string;
+};
+export type FindElementByDomSelector = {
+    baseUrl: string;
+    domSelector: string;
+};
+export type FindElement = FindElementByRoleAndName & FindElementByDomSelector;
+export declare enum ElementServiceType {
+    EXPECT = 0,
+    CLICK = 1,
+    TYPE = 2,
+    WITHIN = 3
+}
+export declare function getElementService(serviceType: ElementServiceType): AbstractElementService;
+export declare class ExpectTableService {
+    static generateExpectForTable(baseUrl: string, innerHtmlFilePath: string): Promise<string>;
 }

package/dist/lib/services/expect.service.js

@@ -1,17 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExpectService = void 0;
+exports.ExpectTableService = exports.ElementServiceType = void 0;
+exports.getElementService = getElementService;
 const tslib_1 = require("tslib");
 const assistant_1 = require("@uuv/assistant");
 const jsdom_1 = require("jsdom");
 const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
-class ExpectService {
-    static generateForAccessibleNameAndRole(baseUrl, accessibleName, accessibleRole) {
-        const translator = new assistant_1.ExpectTranslator();
-        const result = translator.getSentenceFromAccessibleRoleAndName(accessibleRole, accessibleName);
-        return (0, assistant_1.buildResultingScript)("Your amazing feature name", "Action - An action", result.sentences, baseUrl);
+const click_element_service_1 = require("./element/click-element.service");
+const type_element_service_1 = require("./element/type-element.service");
+const within_element_service_1 = require("./element/within-element.service");
+const expect_element_service_1 = require("./element/expect-element.service");
+var ElementServiceType;
+(function (ElementServiceType) {
+    ElementServiceType[ElementServiceType["EXPECT"] = 0] = "EXPECT";
+    ElementServiceType[ElementServiceType["CLICK"] = 1] = "CLICK";
+    ElementServiceType[ElementServiceType["TYPE"] = 2] = "TYPE";
+    ElementServiceType[ElementServiceType["WITHIN"] = 3] = "WITHIN";
+})(ElementServiceType || (exports.ElementServiceType = ElementServiceType = {}));
+function getElementService(serviceType) {
+    switch (serviceType) {
+        case ElementServiceType.CLICK:
+            return new click_element_service_1.ClickElementService();
+        case ElementServiceType.TYPE:
+            return new type_element_service_1.TypeElementService();
+        case ElementServiceType.WITHIN:
+            return new within_element_service_1.WithinElementService();
+        case ElementServiceType.EXPECT:
+        default:
+            return new expect_element_service_1.ExpectElementService();
     }
-    static async generateForTable(baseUrl, innerHtmlFilePath) {
+}
+class ExpectTableService {
+    static async generateExpectForTable(baseUrl, innerHtmlFilePath) {
         const tableAndGridService = new assistant_1.TableAndGridService();
         const dom = new jsdom_1.JSDOM(node_fs_1.default.readFileSync(innerHtmlFilePath, "utf8"));
         const element = dom.window.document.body.firstElementChild;
@@ -19,4 +39,4 @@ class ExpectService {
         return (0, assistant_1.buildResultingScript)("Your amazing feature name", "Action - Expect Array", result, baseUrl);
     }
 }
-exports.ExpectService = ExpectService;
+exports.ExpectTableService = ExpectTableService;

package/dist/lib/services/prompt-retriever.service.d.ts

@@ -1,10 +1,16 @@
 type PromptExtraArgs = Record<string, any>;
 export type PromptArgs = {
-    promptName: string;
+    promptName: UUV_PROMPT;
 } | PromptExtraArgs;
+export declare enum UUV_PROMPT {
+    GENERATE_TEST_EXPECT_TABLE = "generate_test_expect_table",
+    GENERATE_TEST_EXPECT_ELEMENT = "generate_test_expect_element",
+    GENERATE_TEST_CLICK_ELEMENT = "generate_test_click_element",
+    GENERATE_TEST_WITHIN_ELEMENT = "generate_test_within_element",
+    GENERATE_TEST_TYPE_ELEMENT = "generate_test_type_element"
+}
 export declare class PromptRetrieverService {
     private static loadPromptTemplate;
-    private static renderPrompt;
     private static generatePrompt;
     private static validatePromptGenerationRequest;
     static retrievePrompt(args: PromptArgs): string;

package/dist/lib/services/prompt-retriever.service.js

@@ -1,57 +1,69 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PromptRetrieverService = void 0;
+exports.PromptRetrieverService = exports.UUV_PROMPT = void 0;
 const tslib_1 = require("tslib");
 const path = tslib_1.__importStar(require("node:path"));
 const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
 const zod_1 = require("zod");
+const mustache_1 = require("mustache");
+var UUV_PROMPT;
+(function (UUV_PROMPT) {
+    UUV_PROMPT["GENERATE_TEST_EXPECT_TABLE"] = "generate_test_expect_table";
+    UUV_PROMPT["GENERATE_TEST_EXPECT_ELEMENT"] = "generate_test_expect_element";
+    UUV_PROMPT["GENERATE_TEST_CLICK_ELEMENT"] = "generate_test_click_element";
+    UUV_PROMPT["GENERATE_TEST_WITHIN_ELEMENT"] = "generate_test_within_element";
+    UUV_PROMPT["GENERATE_TEST_TYPE_ELEMENT"] = "generate_test_type_element";
+})(UUV_PROMPT || (exports.UUV_PROMPT = UUV_PROMPT = {}));
 class PromptRetrieverService {
     static loadPromptTemplate(promptName) {
         const templatePath = path.join(__dirname, "..", "prompts", `${promptName}.mustache`);
         return node_fs_1.default.readFileSync(templatePath, "utf8");
     }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    static renderPrompt(template, variables) {
-        let result = template;
-        for (const [key, value] of Object.entries(variables)) {
-            if (Array.isArray(value)) {
-                // Handle array values for Mustache-style list rendering
-                const listItems = value.map(item => `{{#${key}}}${item}{{/${key}}}`).join("\n");
-                result = result.replaceAll(`{{#${key}}}`, listItems);
-            }
-            else {
-                result = result.replaceAll(`{{${key}}}`, value);
-            }
-        }
-        return result;
-    }
     static generatePrompt(args) {
         const template = this.loadPromptTemplate(args.promptName);
-        return this.renderPrompt(template, args);
+        return (0, mustache_1.render)(template, args);
     }
     static validatePromptGenerationRequest(args) {
         const promptSchemas = zod_1.z.discriminatedUnion("promptName", [
             zod_1.z.object({
-                promptName: zod_1.z.literal("generate_table"),
+                promptName: zod_1.z.literal(UUV_PROMPT.GENERATE_TEST_EXPECT_TABLE),
                 baseUrl: zod_1.z.string().describe("The base URL of the page where the table/grid/treegrid is located."),
             }),
             zod_1.z.object({
-                promptName: zod_1.z.literal("generate_role_and_name"),
+                promptName: zod_1.z.enum([
+                    UUV_PROMPT.GENERATE_TEST_EXPECT_ELEMENT,
+                    UUV_PROMPT.GENERATE_TEST_CLICK_ELEMENT,
+                    UUV_PROMPT.GENERATE_TEST_WITHIN_ELEMENT,
+                    UUV_PROMPT.GENERATE_TEST_TYPE_ELEMENT
+                ]),
                 baseUrl: zod_1.z.string().describe("The base URL of the page where the element is located."),
-                accessibleName: zod_1.z.string().describe("Accessible name of the element"),
-                accessibleRole: zod_1.z.string().describe("Accessible role of the element"),
+                accessibleName: zod_1.z.string().optional().describe("Accessible name of the element"),
+                accessibleRole: zod_1.z.string().optional().describe("Accessible role of the element"),
+                domSelector: zod_1.z.string().optional().describe("Dom selector of the element"),
             }),
-        ]);
+        ]).superRefine((data, ctx) => {
+            if (data.promptName === UUV_PROMPT.GENERATE_TEST_EXPECT_ELEMENT || data.promptName === UUV_PROMPT.GENERATE_TEST_CLICK_ELEMENT) {
+                const hasAccessibleSelector = data.accessibleRole && data.accessibleName;
+                const hasDomSelector = data.domSelector;
+                if (!hasAccessibleSelector && !hasDomSelector) {
+                    ctx.addIssue({
+                        code: zod_1.z.ZodIssueCode.custom,
+                        message: "You must provide either (accessibleRole AND accessibleName) or domSelector",
+                    });
+                }
+            }
+        });
         return promptSchemas.parse(args);
     }
     static retrievePrompt(args) {
         const validatedPrompt = PromptRetrieverService.validatePromptGenerationRequest(args);
         let prompt;
         switch (validatedPrompt.promptName) {
-            case "generate_table":
-                prompt = PromptRetrieverService.generatePrompt(args);
-                break;
-            case "generate_role_and_name":
+            case UUV_PROMPT.GENERATE_TEST_EXPECT_TABLE:
+            case UUV_PROMPT.GENERATE_TEST_EXPECT_ELEMENT:
+            case UUV_PROMPT.GENERATE_TEST_CLICK_ELEMENT:
+            case UUV_PROMPT.GENERATE_TEST_TYPE_ELEMENT:
+            case UUV_PROMPT.GENERATE_TEST_WITHIN_ELEMENT:
                 prompt = PromptRetrieverService.generatePrompt(args);
                 break;
             default:

package/dist/lib/services/sentence.service.d.ts

@@ -1,4 +1,4 @@
-import { Dictionary } from "@uuv/dictionary";
+import { BaseSentence, Dictionary } from "@uuv/dictionary";
 export type SentenceSearchQuery = {
     category?: string;
     role?: string;
@@ -8,5 +8,5 @@ export declare class SentenceService {
     constructor(dictionary: Dictionary);
     private getBaseSentences;
     private getSentencesByRole;
-    searchSentences(query: SentenceSearchQuery): import("@uuv/dictionary").BaseSentence[];
+    searchSentences(query: SentenceSearchQuery): BaseSentence[];
 }

package/dist/lib/services/sentence.service.js

@@ -13,7 +13,10 @@ class SentenceService {
         return this.dictionary.getRoleBasedSentences().filter(r => !role || r.role === role);
     }
     searchSentences(query) {
-        let sentences = [...this.getBaseSentences()];
+        let sentences = [];
+        if (!query.role && !query.category) {
+            sentences = [...this.getBaseSentences()];
+        }
         sentences.push(...this.getSentencesByRole(query.role));
         if (query.category) {
             sentences = sentences.filter(s => s.section === query.category);

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uuv/mcp-server",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "A Model Context Protocol (MCP) server for UUV - a solution to facilitate the writing and execution of E2E tests understandable by any human being(English or French) using cucumber(BDD) and cypress or playwright.",
   "author": "Louis Fredice NJAKO MOLOM (https://github.com/luifr10) & Stanley SERVICAL (https://github.com/stanlee974)",
   "license": "MIT",
@@ -40,6 +40,7 @@
   ],
   "scripts": {
     "start": "ts-node src/lib/mcp-server.ts",
+    "inspector": "npx @modelcontextprotocol/inspector --config test-mcp.json --server default-server",
     "lint": "npx eslint . --ext .js,.ts,.feature --fix",
     "tests": "jest --coverage --config=./jest.config.ts",
     "package": "npm pack --pack-destination=\"../../dist/packages\""
@@ -56,15 +57,21 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.17.5",
+    "@types/mustache": "^4.2.6",
+    "@uuv/assistant": "2.73.2",
+    "@uuv/dictionary": "0.1.1",
     "jsdom": "26.1.0",
+    "mustache": "^4.2.0",
     "tsconfig-paths": "4.2.0",
     "tslib": "2.3.0",
-    "@uuv/dictionary": "0.1.1",
-    "@uuv/assistant": "2.73.2",
     "zod": "3.25.76"
   },
   "funding": {
     "type": "opencollective",
     "url": "https://opencollective.com/uuv"
+  },
+  "devDependencies": {
+    "@modelcontextprotocol/inspector": "^0.17.2",
+    "ts-node": "^10.9.2"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uuv/mcp-server",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "A Model Context Protocol (MCP) server for UUV - a solution to facilitate the writing and execution of E2E tests understandable by any human being(English or French) using cucumber(BDD) and cypress or playwright.",
   "author": "Louis Fredice NJAKO MOLOM (https://github.com/luifr10) & Stanley SERVICAL (https://github.com/stanlee974)",
   "license": "MIT",
@@ -40,6 +40,7 @@
   ],
   "scripts": {
     "start": "ts-node src/lib/mcp-server.ts",
+    "inspector": "npx @modelcontextprotocol/inspector --config test-mcp.json --server default-server",
     "lint": "npx eslint . --ext .js,.ts,.feature --fix",
     "tests": "jest --coverage --config=./jest.config.ts",
     "package": "npm pack --pack-destination=\"../../dist/packages\""
@@ -56,15 +57,21 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.17.5",
+    "@types/mustache": "^4.2.6",
+    "@uuv/assistant": "2.74.0",
+    "@uuv/dictionary": "0.2.0",
     "jsdom": "26.1.0",
+    "mustache": "^4.2.0",
     "tsconfig-paths": "4.2.0",
     "tslib": "2.3.0",
-    "@uuv/dictionary": "0.1.1",
-    "@uuv/assistant": "2.73.2",
     "zod": "3.25.76"
   },
   "funding": {
     "type": "opencollective",
     "url": "https://opencollective.com/uuv"
+  },
+  "devDependencies": {
+    "@modelcontextprotocol/inspector": "^0.17.2",
+    "ts-node": "^10.9.2"
   }
 }