@godscene/core 1.7.11

package/dist/lib/ai-model/prompt/yaml-generator.js

@@ -0,0 +1,262 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createEventCounts: ()=>createEventCounts,
+    filterEventsByType: ()=>filterEventsByType,
+    processEventsForLLM: ()=>processEventsForLLM,
+    validateEvents: ()=>validateEvents,
+    createMessageContent: ()=>createMessageContent,
+    generateYamlTestStream: ()=>generateYamlTestStream,
+    getScreenshotsForLLM: ()=>getScreenshotsForLLM,
+    extractInputDescriptions: ()=>extractInputDescriptions,
+    prepareEventSummary: ()=>prepareEventSummary,
+    generateYamlTest: ()=>generateYamlTest
+});
+const constants_namespaceObject = require("@godscene/shared/constants");
+const external_index_js_namespaceObject = require("../index.js");
+const getScreenshotsForLLM = (events, maxScreenshots = 1)=>{
+    const eventsWithScreenshots = events.filter((event)=>event.screenshotBefore || event.screenshotAfter || event.screenshotWithBox);
+    const sortedEvents = [
+        ...eventsWithScreenshots
+    ].sort((a, b)=>{
+        if ('navigation' === a.type && 'navigation' !== b.type) return -1;
+        if ('navigation' !== a.type && 'navigation' === b.type) return 1;
+        if ('click' === a.type && 'click' !== b.type) return -1;
+        if ('click' !== a.type && 'click' === b.type) return 1;
+        return 0;
+    });
+    const screenshots = [];
+    for (const event of sortedEvents){
+        const screenshot = event.screenshotWithBox || event.screenshotAfter || event.screenshotBefore;
+        if (screenshot && !screenshots.includes(screenshot)) {
+            screenshots.push(screenshot);
+            if (screenshots.length >= maxScreenshots) break;
+        }
+    }
+    return screenshots;
+};
+const filterEventsByType = (events)=>({
+        navigationEvents: events.filter((event)=>'navigation' === event.type),
+        clickEvents: events.filter((event)=>'click' === event.type),
+        inputEvents: events.filter((event)=>'input' === event.type),
+        scrollEvents: events.filter((event)=>'scroll' === event.type)
+    });
+const createEventCounts = (filteredEvents, totalEvents)=>({
+        navigation: filteredEvents.navigationEvents.length,
+        click: filteredEvents.clickEvents.length,
+        input: filteredEvents.inputEvents.length,
+        scroll: filteredEvents.scrollEvents.length,
+        total: totalEvents
+    });
+const extractInputDescriptions = (inputEvents)=>inputEvents.map((event)=>({
+            description: event.elementDescription || '',
+            value: event.value || ''
+        })).filter((item)=>item.description && item.value);
+const processEventsForLLM = (events)=>events.map((event)=>({
+            type: event.type,
+            timestamp: event.timestamp,
+            url: event.url,
+            title: event.title,
+            elementDescription: event.elementDescription,
+            value: event.value,
+            pageInfo: event.pageInfo,
+            elementRect: event.elementRect
+        }));
+const prepareEventSummary = (events, options = {})=>{
+    const filteredEvents = filterEventsByType(events);
+    const eventCounts = createEventCounts(filteredEvents, events.length);
+    const startUrl = filteredEvents.navigationEvents.length > 0 ? filteredEvents.navigationEvents[0].url || '' : '';
+    const clickDescriptions = filteredEvents.clickEvents.map((event)=>event.elementDescription).filter((desc)=>Boolean(desc)).slice(0, 10);
+    const inputDescriptions = extractInputDescriptions(filteredEvents.inputEvents).slice(0, 10);
+    const urls = filteredEvents.navigationEvents.map((e)=>e.url).filter((url)=>Boolean(url)).slice(0, 5);
+    const processedEvents = processEventsForLLM(events);
+    return {
+        testName: options.testName || 'Automated test from recorded events',
+        startUrl,
+        eventCounts,
+        urls,
+        clickDescriptions,
+        inputDescriptions,
+        events: processedEvents
+    };
+};
+const createMessageContent = (promptText, screenshots = [], includeScreenshots = true)=>{
+    const messageContent = [
+        {
+            type: 'text',
+            text: promptText
+        }
+    ];
+    if (includeScreenshots && screenshots.length > 0) {
+        messageContent.unshift({
+            type: 'text',
+            text: 'Here are screenshots from the recording session to help you understand the context:'
+        });
+        screenshots.forEach((screenshot)=>{
+            messageContent.push({
+                type: 'image_url',
+                image_url: {
+                    url: screenshot
+                }
+            });
+        });
+    }
+    return messageContent;
+};
+const getYamlLanguageInstruction = (language)=>{
+    const normalizedLanguage = language?.trim();
+    if (!normalizedLanguage) return '';
+    return `
+Language requirement:
+- Write all human-readable YAML content in ${normalizedLanguage}.
+- Keep YAML keys, field names, and Midscene API names unchanged.`;
+};
+const createYamlPrompt = ({ yamlSummary, screenshots, language })=>{
+    const prompt = [
+        {
+            role: 'system',
+            content: `You are an expert in RPA智能助手 YAML test generation. Generate clean, accurate YAML following these rules: ${constants_namespaceObject.YAML_EXAMPLE_CODE}`
+        },
+        {
+            role: 'user',
+            content: `Generate YAML test for RPA智能助手 automation from recorded browser events.
+
+Event Summary:
+${JSON.stringify(yamlSummary, null, 2)}
+
+Convert events:
+- navigation → target.url
+- click → aiTap with element description
+- input → aiInput with value and locate
+- scroll → aiScroll with appropriate direction
+- Add aiAssert for important state changes${getYamlLanguageInstruction(language)}
+
+Important: Return ONLY the raw YAML content. Do NOT wrap the response in markdown code blocks (no \`\`\`yaml or \`\`\`). Start directly with the YAML content.`
+        }
+    ];
+    if (screenshots.length > 0) {
+        prompt.push({
+            role: 'user',
+            content: 'Here are screenshots from the recording session to help you understand the context:'
+        });
+        prompt.push({
+            role: 'user',
+            content: screenshots.map((screenshot)=>({
+                    type: 'image_url',
+                    image_url: {
+                        url: screenshot
+                    }
+                }))
+        });
+    }
+    return prompt;
+};
+const validateEvents = (events)=>{
+    if (!events.length) throw new Error('No events provided for test generation');
+};
+const generateYamlTest = async (events, options, modelConfig)=>{
+    try {
+        validateEvents(events);
+        const summary = prepareEventSummary(events, {
+            testName: options.testName,
+            maxScreenshots: options.maxScreenshots || 3
+        });
+        const yamlSummary = {
+            ...summary,
+            includeTimestamps: options.includeTimestamps || false
+        };
+        const screenshots = getScreenshotsForLLM(events, options.maxScreenshots || 3);
+        const prompt = createYamlPrompt({
+            yamlSummary,
+            screenshots,
+            language: options.language
+        });
+        const response = await (0, external_index_js_namespaceObject.callAIWithStringResponse)(prompt, modelConfig);
+        if (response?.content && 'string' == typeof response.content) return response.content;
+        throw new Error('Failed to generate YAML test configuration');
+    } catch (error) {
+        throw new Error(`Failed to generate YAML test: ${error}`);
+    }
+};
+const generateYamlTestStream = async (events, options, modelConfig)=>{
+    try {
+        validateEvents(events);
+        const summary = prepareEventSummary(events, {
+            testName: options.testName,
+            maxScreenshots: options.maxScreenshots || 3
+        });
+        const yamlSummary = {
+            ...summary,
+            includeTimestamps: options.includeTimestamps || false
+        };
+        const screenshots = getScreenshotsForLLM(events, options.maxScreenshots || 3);
+        const prompt = createYamlPrompt({
+            yamlSummary,
+            screenshots,
+            language: options.language
+        });
+        if (options.stream && options.onChunk) return await (0, external_index_js_namespaceObject.callAI)(prompt, modelConfig, {
+            stream: true,
+            onChunk: options.onChunk
+        });
+        {
+            const response = await (0, external_index_js_namespaceObject.callAIWithStringResponse)(prompt, modelConfig);
+            if (response?.content && 'string' == typeof response.content) return {
+                content: response.content,
+                usage: response.usage,
+                isStreamed: false
+            };
+            throw new Error('Failed to generate YAML test configuration');
+        }
+    } catch (error) {
+        throw new Error(`Failed to generate YAML test: ${error}`);
+    }
+};
+exports.createEventCounts = __webpack_exports__.createEventCounts;
+exports.createMessageContent = __webpack_exports__.createMessageContent;
+exports.extractInputDescriptions = __webpack_exports__.extractInputDescriptions;
+exports.filterEventsByType = __webpack_exports__.filterEventsByType;
+exports.generateYamlTest = __webpack_exports__.generateYamlTest;
+exports.generateYamlTestStream = __webpack_exports__.generateYamlTestStream;
+exports.getScreenshotsForLLM = __webpack_exports__.getScreenshotsForLLM;
+exports.prepareEventSummary = __webpack_exports__.prepareEventSummary;
+exports.processEventsForLLM = __webpack_exports__.processEventsForLLM;
+exports.validateEvents = __webpack_exports__.validateEvents;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createEventCounts",
+    "createMessageContent",
+    "extractInputDescriptions",
+    "filterEventsByType",
+    "generateYamlTest",
+    "generateYamlTestStream",
+    "getScreenshotsForLLM",
+    "prepareEventSummary",
+    "processEventsForLLM",
+    "validateEvents"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});