donobu 3.4.0 → 3.5.1

package/dist/managers/CodeGenerator.js

@@ -1,886 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CodeGenerator = void 0;
-const fs = __importStar(require("fs"));
-const cacheEntryBuilder_1 = require("../lib/pageAi/cacheEntryBuilder");
-const AnalyzePageTextTool_1 = require("../tools/AnalyzePageTextTool");
-const AssertPageTool_1 = require("../tools/AssertPageTool");
-const AssertTool_1 = require("../tools/AssertTool");
-const ChangeWebBrowserTabTool_1 = require("../tools/ChangeWebBrowserTabTool");
-const ChooseSelectOptionTool_1 = require("../tools/ChooseSelectOptionTool");
-const ClickTool_1 = require("../tools/ClickTool");
-const CreateBrowserCookieReportTool_1 = require("../tools/CreateBrowserCookieReportTool");
-const GoForwardOrBackTool_1 = require("../tools/GoForwardOrBackTool");
-const GoToWebpageTool_1 = require("../tools/GoToWebpageTool");
-const HoverOverElementTool_1 = require("../tools/HoverOverElementTool");
-const InputRandomizedEmailAddressTool_1 = require("../tools/InputRandomizedEmailAddressTool");
-const InputTextTool_1 = require("../tools/InputTextTool");
-const MakeCommentTool_1 = require("../tools/MakeCommentTool");
-const MarkObjectiveCompleteTool_1 = require("../tools/MarkObjectiveCompleteTool");
-const MarkObjectiveNotCompletableTool_1 = require("../tools/MarkObjectiveNotCompletableTool");
-const PressKeyTool_1 = require("../tools/PressKeyTool");
-const ReloadPageTool_1 = require("../tools/ReloadPageTool");
-const RememberPageTextTool_1 = require("../tools/RememberPageTextTool");
-const ReplayableInteraction_1 = require("../tools/ReplayableInteraction");
-const RunAccessibilityTestTool_1 = require("../tools/RunAccessibilityTestTool");
-const ScrollPageTool_1 = require("../tools/ScrollPageTool");
-const SummarizeLearningsTool_1 = require("../tools/SummarizeLearningsTool");
-const WaitTool_1 = require("../tools/WaitTool");
-const JsonUtils_1 = require("../utils/JsonUtils");
-const Logger_1 = require("../utils/Logger");
-const FlowDependencyAnalyzer_1 = require("./FlowDependencyAnalyzer");
-const ToolManager_1 = require("./ToolManager");
-function getLocalPlaywrightVersion() {
-    const pkgPath = require.resolve('playwright/package.json');
-    const pkgJson = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-    return pkgJson.version;
-}
-const PLAYWRIGHT_VERSION = getLocalPlaywrightVersion();
-class CodeGenerator {
-    /** Creates a Node.js Microsoft Playwright script to replay the given flow. */
-    async getFlowAsPlaywrightScript(flowMetadata, toolCalls) {
-        // These tools are not supported in the generated script because they have
-        // static outputs that have no side effects, so they are not actually
-        // doing anything.
-        const unsupportedToolsByName = new Set([
-            MakeCommentTool_1.MakeCommentTool.NAME,
-            MarkObjectiveCompleteTool_1.MarkObjectiveCompleteTool.NAME,
-            MarkObjectiveNotCompletableTool_1.MarkObjectiveNotCompletableTool.NAME,
-            SummarizeLearningsTool_1.SummarizeLearningsTool.NAME,
-        ]);
-        const envVarsAnnotations = (flowMetadata.envVars ?? []).map((env) => {
-            return `{
-        type: 'ENV',
-        description: '${env}'
-      }`;
-        });
-        const allTools = await ToolManager_1.ToolManager.allTools();
-        const isGptClientRequired = this.isGptClientRequired(flowMetadata, toolCalls, allTools);
-        const gptSetupNote = isGptClientRequired
-            ? `* Note that this test uses tools that require the usage of an LLM, so be
- * sure to have an appropriate LLM API key available. This can be done
- * by providing an environment variable (e.g. OPENAI_API_KEY, ANTHROPIC_API_KEY,
- * or GOOGLE_GENERATIVE_AI_API_KEY) when running the test...
- *
- *    Example: \`OPENAI_API_KEY=YOUR_KEY npx playwright test\`
- *
- * ...or by configuring a flow runner using the Donobu app.
- `
-            : ' ';
-        const hasObjective = (flowMetadata.overallObjective?.trim().length ?? 0) > 0;
-        const testDetails = hasObjective
-            ? `{
-          annotation: [
-            {
-              type: 'objective',
-              description: \`${this.sanitizeForTemplateLiteral(flowMetadata.overallObjective ?? '')}\`
-            },
-            ${envVarsAnnotations.join(',')}
-          ]
-        }`
-            : '{}';
-        const testName = flowMetadata.name
-            ? flowMetadata.name
-                // Escape backslashes first.
-                .replace(/\\/g, '\\\\')
-                // Escape single quotes.
-                .replace(/'/g, "\\'")
-                // Escape newlines.
-                .replace(/\n/g, '\\n')
-                // Escape carriage returns.
-                .replace(/\r/g, '\\r')
-            : `Test for ${flowMetadata.targetWebsite}`;
-        const useStorageState = flowMetadata.browser && flowMetadata.browser.initialState
-            ? `storageState: getBrowserStorageStateFixture(${JSON.stringify(flowMetadata.browser.initialState, null, 2)}),`
-            : undefined;
-        let testExtension = '';
-        if (useStorageState) {
-            testExtension = `.extend({${useStorageState}})`;
-        }
-        const scriptedToolCalls = toolCalls
-            .filter((toolCall) => !unsupportedToolsByName.has(toolCall.name))
-            .map((toolCall) => {
-            return this.convertProposedToolCallToPlaywrightCode(toolCall);
-        })
-            .join('\n');
-        const resultJson = flowMetadata.resultJsonSchema
-            ? `// Extract an object from the page using the following JSON-schema.
-const extractedObject = await page.ai.extract(
-  jsonSchemaToZod(${JSON.stringify(flowMetadata.resultJsonSchema)})
-);
-testInfo.attach('extracted-object', { body: JSON.stringify(extractedObject), contentType: 'application/json' });`
-            : '';
-        const needsExpectImport = toolCalls.some((toolCall) => toolCall.name === AssertPageTool_1.AssertPageTool.NAME);
-        const needsJsonSchemaToZodImport = flowMetadata.resultJsonSchema;
-        const preamble = gptSetupNote.trim().length > 0
-            ? `/**
-${gptSetupNote}*/`
-            : '';
-        const script = `${preamble}
-import { test${needsExpectImport ? ', expect' : ''}${needsJsonSchemaToZodImport ? ', jsonSchemaToZod' : ''} } from 'donobu';${useStorageState
-            ? "\nimport { getBrowserStorageStateFixture } from 'donobu';"
-            : ''}
-
-const title = '${testName}';
-const details = ${testDetails};
-test${testExtension}(title, details, async ({ page }${flowMetadata.resultJsonSchema ? ', testInfo' : ''}) => {
-${scriptedToolCalls}
-${resultJson}
-});
-`;
-        return this.prettifyCode(script);
-    }
-    /** Creates a Node.js Microsoft Playwright script to replay the given flow. */
-    async getFlowAsAiPlaywrightScript(flowMetadata, toolCalls) {
-        const gptSetupNote = ` * This test replays a recorded Donobu flow via \`page.ai.act(...)\` using the cached
- * tool calls stored alongside this spec in \`donobu.json\`. If the cache entry
- * is missing or the parameters change, the run falls back to autonomous mode
- * and will require a GPT API key (e.g. OPENAI_API_KEY, ANTHROPIC_API_KEY, or
- * GOOGLE_GENERATIVE_AI_API_KEY).
-`;
-        const testName = flowMetadata.name
-            ? flowMetadata.name
-                // Escape backslashes first.
-                .replace(/\\/g, '\\\\')
-                // Escape single quotes.
-                .replace(/'/g, "\\'")
-                // Escape newlines.
-                .replace(/\n/g, '\\n')
-                // Escape carriage returns.
-                .replace(/\r/g, '\\r')
-            : `Test for ${flowMetadata.targetWebsite}`;
-        const useStorageState = flowMetadata.browser && flowMetadata.browser.initialState
-            ? `storageState: getBrowserStorageStateFixture(${JSON.stringify(flowMetadata.browser.initialState, null, 2)}),`
-            : undefined;
-        let testExtension = '';
-        if (useStorageState) {
-            testExtension = `.extend({${useStorageState}})`;
-        }
-        const instructionSource = flowMetadata.overallObjective &&
-            flowMetadata.overallObjective.trim().length > 0
-            ? flowMetadata.overallObjective
-            : `Replay the recorded flow for ${flowMetadata.targetWebsite}`;
-        const sanitizedInstruction = this.sanitizeForTemplateLiteral(instructionSource);
-        const defaultToolNames = new Set((await ToolManager_1.ToolManager.defaultTools()).map((tool) => tool.name));
-        const toolNamesFromCalls = Array.from(new Set(toolCalls.map((toolCall) => toolCall.name))).sort();
-        const usesNonDefaultTool = toolNamesFromCalls.some((toolName) => !defaultToolNames.has(toolName));
-        const optionsLines = [];
-        const needsJsonSchemaToZodImport = flowMetadata.resultJsonSchema !== null;
-        if (flowMetadata.resultJsonSchema) {
-            optionsLines.push(`schema: jsonSchemaToZod(${JSON.stringify(flowMetadata.resultJsonSchema)})`);
-        }
-        if (usesNonDefaultTool && toolNamesFromCalls.length > 0) {
-            optionsLines.push(`allowedTools: ${JSON.stringify(toolNamesFromCalls)}`);
-        }
-        if (flowMetadata.maxToolCalls !== null) {
-            optionsLines.push(`maxToolCalls: ${flowMetadata.maxToolCalls}`);
-        }
-        if (flowMetadata.envVars && flowMetadata.envVars.length > 0) {
-            optionsLines.push(`envVars: ${JSON.stringify(flowMetadata.envVars)}`);
-        }
-        const aiOptionsLiteral = optionsLines.length > 0
-            ? `{\n${optionsLines.map((line) => `    ${line}`).join(',\n')}\n  }`
-            : '';
-        const aiCallExpression = optionsLines.length > 0
-            ? `page.ai.act(\`${sanitizedInstruction}\`, ${aiOptionsLiteral})`
-            : `page.ai.act(\`${sanitizedInstruction}\`)`;
-        const needsTestInfo = flowMetadata.resultJsonSchema !== null;
-        const cacheComment = '  // Cached tool calls for this flow live in donobu.json next to this spec.\n';
-        const aiInvocation = needsTestInfo
-            ? `  const aiResult = await ${aiCallExpression};
-  await testInfo.attach('extracted-object', { body: JSON.stringify(aiResult, null, 2), contentType: 'application/json' });
-`
-            : `  await ${aiCallExpression};
-`;
-        const preamble = `/**
-${gptSetupNote}*/`;
-        const script = `${preamble}
-import { test${needsJsonSchemaToZodImport ? ', jsonSchemaToZod' : ''} } from 'donobu';${useStorageState ? "\nimport { getBrowserStorageStateFixture } from 'donobu';" : ''}
-
-test${testExtension}('${testName}', async ({ page }${needsTestInfo ? ', testInfo' : ''}) => {
-${cacheComment}${aiInvocation}});
-`;
-        return this.prettifyCode(script);
-    }
-    /**
-     * Generates a complete Playwright project structure with dependency management.
-     */
-    async generateProject(flowsWithToolCalls, gptConfig, options) {
-        // Analyze dependencies
-        const flowsMetadata = flowsWithToolCalls.map((f) => f.metadata);
-        const dependencyGraph = FlowDependencyAnalyzer_1.FlowDependencyAnalyzer.analyzeDependencies(flowsMetadata);
-        const files = [];
-        // Generate individual test files
-        const testFiles = await this.generateTestFiles(flowsWithToolCalls);
-        files.push(...testFiles);
-        // Generate playwright.config.ts
-        files.push({
-            path: 'playwright.config.ts',
-            content: await this.generatePlaywrightConfig(dependencyGraph, options),
-        });
-        files.push({
-            path: '.github/workflows/run-tests.yml',
-            content: await this.generateGitHubActionsWorkflow(flowsWithToolCalls, gptConfig, options),
-        });
-        // Generate package.json if needed
-        files.push({
-            path: 'package.json',
-            content: this.generatePackageJson(),
-        });
-        // Generate README
-        files.push({
-            path: 'README.md',
-            content: this.generateReadme(),
-        });
-        files.push({
-            path: '.gitignore',
-            content: this.generateGitIgnore(),
-        });
-        const cacheFile = this.buildCacheFile(flowsWithToolCalls);
-        if (cacheFile) {
-            files.push(cacheFile);
-        }
-        return { files };
-    }
-    async generateGitHubActionsWorkflow(flowsWithToolCalls, gptConfig, options) {
-        const flowsMetadata = flowsWithToolCalls.map((f) => f.metadata);
-        const allUniqueEnvVars = [
-            ...new Set(flowsMetadata.flatMap((flow) => flow.envVars || [])),
-        ];
-        const allTools = await ToolManager_1.ToolManager.allTools();
-        const isGptClientRequired = flowsWithToolCalls.some((f) => {
-            return this.isGptClientRequired(f.metadata, f.toolCalls, allTools);
-        }) || !options.disableSelfHealingTests;
-        const envVarsList = [];
-        if (!options.disableSelfHealingTests) {
-            envVarsList.push('SELF_HEAL_TESTS_ENABLED: true');
-        }
-        if (isGptClientRequired) {
-            const defaultGptSetup = [
-                '# Uncomment the desired GPT provider and set up the secret in GitHub.',
-                '# ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}',
-                '# GOOGLE_GENERATIVE_AI_API_KEY: ${{ secrets.GOOGLE_GENERATIVE_AI_API_KEY }}',
-                '# OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}',
-            ];
-            if (gptConfig) {
-                switch (gptConfig.type) {
-                    case 'ANTHROPIC':
-                        envVarsList.push('ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}', `ANTHROPIC_MODEL_NAME: "${gptConfig.modelName}"`);
-                        break;
-                    case 'ANTHROPIC_AWS_BEDROCK':
-                        envVarsList.push('AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}', `AWS_ACCESS_KEY_ID: ${gptConfig.accessKeyId}`, `AWS_REGION: ${gptConfig.region}`, `AWS_BEDROCK_MODEL_NAME: "${gptConfig.modelName}"`);
-                        break;
-                    case 'DONOBU':
-                        envVarsList.push('DONOBU_API_KEY: ${{ secrets.DONOBU_API_KEY }}');
-                        break;
-                    case 'GOOGLE_GEMINI':
-                        envVarsList.push('GOOGLE_GENERATIVE_AI_API_KEY: ${{ secrets.GOOGLE_GENERATIVE_AI_API_KEY }}', `GOOGLE_GENERATIVE_AI_MODEL_NAME: "${gptConfig.modelName}"`);
-                        break;
-                    case 'OPENAI':
-                        envVarsList.push('OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}', `OPENAI_API_MODEL_NAME: "${gptConfig.modelName}"`);
-                        break;
-                    case 'OPENAI_AZURE':
-                    case 'LLAMA_LOCAL':
-                    case 'LLAMA_HUGGING_FACE':
-                    case 'VERCEL_AI':
-                    default:
-                        envVarsList.push(...defaultGptSetup);
-                }
-            }
-            else {
-                envVarsList.push(...defaultGptSetup);
-            }
-        }
-        envVarsList.push(...allUniqueEnvVars.map((envVarName) => `${envVarName}: \${{ secrets.${envVarName} }}`));
-        const envVarsSection = envVarsList.length > 0
-            ? `\n        env:\n          ${envVarsList.join('\n          ')}`
-            : '';
-        const triggerSection = `
-on:
-  pull_request:
-  workflow_dispatch:`;
-        const xvfbStep = options.runInHeadedMode
-            ? `
-      - name: Install XVFB for headed mode
-        run: sudo apt-get update && sudo apt-get install -y xvfb
-`
-            : '';
-        const testCommand = options.runInHeadedMode
-            ? 'xvfb-run -a npx playwright test'
-            : 'npx playwright test';
-        const pullRequestCreationSection = options.disablePullRequestCreation
-            ? ''
-            : `
-      # Create a self-healing PR only when this workflow was not triggered by a pull-request.
-      - name: Automatically create a pull request for fixing failed tests (if any)
-        if: \${{ github.event_name != 'pull_request' }}
-        uses: peter-evans/create-pull-request@v5
-        with:
-          token: \${{ secrets.GITHUB_TOKEN }}
-          commit-message: "Fix failing Playwright tests"
-          title: "[Fixed] Playwright tests"
-          body: "Fix failing Playwright tests"
-          branch: fix-playwright-tests-for-\${{ github.ref_name }}
-          base: \${{ github.ref_name }}`;
-        return `name: Run Playwright Tests
-${triggerSection}
-
-jobs:
-  run-donobu-flows:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Install dependencies
-        run: npm install && npx playwright install --with-deps
-${xvfbStep}
-      - name: Run Playwright tests
-        id: run_tests
-        continue-on-error: true${envVarsSection}
-        run: ${testCommand}
-
-      - name: Upload Raw Results
-        uses: actions/upload-artifact@v4
-        if: always()
-        with:
-          name: test-results
-          path: test-results/
-          retention-days: 3
-
-      - name: Upload HTML Report
-        uses: actions/upload-artifact@v4
-        if: always()
-        with:
-          name: html-report
-          path: playwright-report/
-          retention-days: 3
-
-      - name: Report test results
-        if: always()
-        run: npm exec playwright-json-to-markdown < "test-results/playwright-report.json" >> $GITHUB_STEP_SUMMARY
-
-      - name: Post to Slack
-        if: always()
-        env:
-          SLACK_WEBHOOK_URL: \${{ secrets.SLACK_WEBHOOK_URL }}
-        run: |
-          if [ -n "$SLACK_WEBHOOK_URL" ]; then
-            WORKFLOW_URL="\${GITHUB_SERVER_URL}/\${GITHUB_REPOSITORY}/actions/runs/\${GITHUB_RUN_ID}"
-            SLACK_PAYLOAD=$(npm exec playwright-json-to-slack-json -- --report-url "$WORKFLOW_URL" < "test-results/playwright-report.json")
-            curl --header 'Content-type: application/json' --data "$SLACK_PAYLOAD" "$SLACK_WEBHOOK_URL"
-          else
-            echo "SLACK_WEBHOOK_URL secret not present, skipping Slack notification."
-          fi
-${pullRequestCreationSection}`;
-    }
-    buildCacheContents(flowsWithToolCalls) {
-        const entries = flowsWithToolCalls.map(({ metadata, toolCalls }) => {
-            const cacheEntry = cacheEntryBuilder_1.PageAiCacheEntryBuilder.fromMetadata(metadata.targetWebsite, metadata, toolCalls);
-            return {
-                ...cacheEntry,
-                allowedTools: [...cacheEntry.allowedTools],
-                toolCallCache: JSON.parse(JSON.stringify(cacheEntry.toolCallCache)),
-                schema: cacheEntry.schema === null
-                    ? null
-                    : JSON.parse(JSON.stringify(cacheEntry.schema)),
-            };
-        });
-        return {
-            caches: entries,
-        };
-    }
-    buildCacheFile(flowsWithToolCalls) {
-        if (flowsWithToolCalls.length === 0) {
-            return null;
-        }
-        const contents = this.buildCacheContents(flowsWithToolCalls);
-        return {
-            path: 'donobu.json',
-            content: JSON.stringify(contents, null, 2),
-        };
-    }
-    /**
-     * Maps a proposed Donobu tool call to valid NodeJS Playwright code that uses
-     * the `DonobuExtendedPage` extension.
-     */
-    convertProposedToolCallToPlaywrightCode(proposedToolCall) {
-        const rawParams = JsonUtils_1.JsonUtils.objectToJson(proposedToolCall.parameters);
-        const rationale = rawParams.rationale && rawParams.rationale.trim().length > 0
-            ? rawParams.rationale
-                .split('\n')
-                .map((line) => `// ${line}`.trim())
-                .join('\n') + '\n'
-            : '';
-        // Delete fields that should not be directly mapped.
-        delete rawParams.rationale;
-        delete rawParams.whyThisAnnotation;
-        delete rawParams.annotation;
-        const hasNonEmptyParameters = Object.keys(rawParams).length > 0;
-        const serializedParams = JSON.stringify(rawParams, null, 2);
-        switch (proposedToolCall.name) {
-            case AssertTool_1.AssertTool.NAME: {
-                const options = {
-                    ...(rawParams.retries > 0 ? { retries: rawParams.retries } : {}),
-                    ...(rawParams.retries > 0 && rawParams.retryWaitSeconds > 0
-                        ? { retryWaitSeconds: rawParams.retryWaitSeconds }
-                        : {}),
-                };
-                const serializedOptions = Object.keys(options).length > 0
-                    ? `,${JSON.stringify(options, null, 2)}`
-                    : '';
-                return `${rationale}await page.ai.assert(
-          ${JSON.stringify(rawParams.assertionToTestFor)}${serializedOptions});`;
-            }
-            case ChangeWebBrowserTabTool_1.ChangeWebBrowserTabTool.NAME: {
-                const url = ChangeWebBrowserTabTool_1.ChangeWebBrowserTabCoreSchema.parse(proposedToolCall.parameters);
-                return `${rationale}page = await page.changeTab(${JSON.stringify(url.tabUrl)});`;
-            }
-            case ChooseSelectOptionTool_1.ChooseSelectOptionTool.NAME: {
-                const find = this.parseFindCall(rawParams);
-                const { selector: _selector, optionValues } = rawParams;
-                return `${rationale}${find}.selectOption(${JSON.stringify(optionValues)})`;
-            }
-            case ClickTool_1.ClickTool.NAME: {
-                const find = this.parseFindCall(rawParams);
-                return `${rationale}${find}.click()`;
-            }
-            case GoForwardOrBackTool_1.GoForwardOrBackTool.NAME: {
-                if (rawParams.direction === 'FORWARD') {
-                    return `${rationale}await page.goForward();`;
-                }
-                else if (rawParams.direction === 'BACK') {
-                    return `${rationale}await page.goBack();`;
-                }
-                else {
-                    throw new Error(`Invalid ${GoForwardOrBackTool_1.GoForwardOrBackTool.NAME} params: ${serializedParams}`);
-                }
-            }
-            case GoToWebpageTool_1.GoToWebpageTool.NAME: {
-                return `${rationale}await page.goto(${JSON.stringify(rawParams.url)});`;
-            }
-            case HoverOverElementTool_1.HoverOverElementTool.NAME: {
-                const find = this.parseFindCall(rawParams);
-                return `${rationale}${find}.hover()`;
-            }
-            case InputRandomizedEmailAddressTool_1.InputRandomizedEmailAddressTool.NAME: {
-                const find = this.parseFindCall(rawParams);
-                const { selector: _selector, baseEmail, finalizeWithSubmit, } = rawParams;
-                return `${rationale}${find}.inputRandomizedEmailAddress(
-          ${JSON.stringify(baseEmail)},
-          ${finalizeWithSubmit ? JSON.stringify({ finalizeWithSubmit }) : ''})`;
-            }
-            case InputTextTool_1.InputTextTool.NAME: {
-                const find = this.parseFindCall(rawParams);
-                const { selector: _selector, text, append, finalizeWithSubmit, } = rawParams;
-                return `${rationale}${find}.inputText(
-          ${JSON.stringify(text)},
-          ${append || finalizeWithSubmit ? JSON.stringify({ append, finalizeWithSubmit }) : ''})`;
-            }
-            case PressKeyTool_1.PressKeyTool.NAME: {
-                const find = this.parseFindCall(rawParams);
-                const { selector: _selector, key } = rawParams;
-                return `${rationale}${find}.pressKey(${JSON.stringify(key)})`;
-            }
-            case ReloadPageTool_1.ReloadPageTool.NAME: {
-                return `${rationale}await page.reload();`;
-            }
-            case ScrollPageTool_1.ScrollPageTool.NAME: {
-                const find = this.parseFindCall(rawParams);
-                const { selector: _selector, direction, maxScroll } = rawParams;
-                return `${rationale}${find}.scroll(
-          ${JSON.stringify(direction)},
-          ${maxScroll ? JSON.stringify({ maxScroll }) : ''})`;
-            }
-            case WaitTool_1.WaitTool.NAME: {
-                return `${rationale}await page.waitForTimeout(${rawParams.seconds * 1000});`;
-            }
-            case AssertPageTool_1.AssertPageTool.NAME: {
-                const assertionType = rawParams.type;
-                const expected = rawParams.expected;
-                const isRegex = rawParams.isRegex || false;
-                switch (assertionType) {
-                    case 'title': {
-                        if (isRegex) {
-                            return `${rationale}await expect(page).toHaveTitle(new RegExp(${JSON.stringify(expected)}));`;
-                        }
-                        else {
-                            return `${rationale}await expect(page).toHaveTitle('${expected}');`;
-                        }
-                    }
-                    case 'url': {
-                        if (isRegex) {
-                            return `${rationale}await expect(page).toHaveURL(new RegExp(${JSON.stringify(expected)}));`;
-                        }
-                        else {
-                            return `${rationale}await expect(page).toHaveURL('${expected}');`;
-                        }
-                    }
-                    case 'content': {
-                        if (isRegex) {
-                            return `${rationale}await expect(page.locator('body')).toContainText(new RegExp(${JSON.stringify(expected)}));`;
-                        }
-                        else {
-                            return `${rationale}await expect(page.getByText('${expected}')).toBeVisible();`;
-                        }
-                    }
-                    default: {
-                        // Fallback to the generic tool call if unknown type
-                        return `${rationale}await page.${proposedToolCall.name}(
-              ${hasNonEmptyParameters ? JSON.stringify({ type: assertionType, expected, isRegex }, null, 2) : ''});`;
-                    }
-                }
-            }
-            case RememberPageTextTool_1.RememberPageTextTool.NAME: {
-                delete rawParams.text;
-                const updatedSerializedParams = JSON.stringify(rawParams, null, 2);
-                return `${rationale}await page.run('${proposedToolCall.name}', ${updatedSerializedParams});`;
-            }
-            case AnalyzePageTextTool_1.AnalyzePageTextTool.NAME: {
-                return `${rationale}await page.ai.analyzePageText(
-          ${JSON.stringify(rawParams.analysisToRun)},
-          ${JSON.stringify({ additionalContext: rawParams.additionalRelevantContext })})`;
-            }
-            case RunAccessibilityTestTool_1.RunAccessibilityTestTool.NAME: {
-                return `${rationale}await page.runAccessibilityTest();`;
-            }
-            case CreateBrowserCookieReportTool_1.CreateBrowserCookieReportTool.NAME: {
-                return `${rationale}await page.ai.createCookieReport();`;
-            }
-            // All other tools delegate to the general 'run' method.
-            default: {
-                const toolName = proposedToolCall.name;
-                const toolCallScript = hasNonEmptyParameters
-                    ? `${rationale}await page.run(${JSON.stringify(toolName)}, ${serializedParams});`
-                    : `${rationale}await page.run(${JSON.stringify(toolName)});`;
-                return toolCallScript;
-            }
-        }
-    }
-    generateGitIgnore() {
-        return `.DS_Store
-.idea
-.vscode
-node_modules
-# Test results generated by Playwright
-test-results
-playwright-report`;
-    }
-    /**
-     * Generates the playwright.config.ts file with project dependencies
-     */
-    async generatePlaywrightConfig(graph, options) {
-        const projects = [];
-        // Create a project for each flow (both single and multiple flows in waves get individual projects)
-        graph.executionOrder.forEach((wave) => {
-            wave.forEach((flowId) => {
-                const flow = graph.flows.get(flowId);
-                const projectName = this.getProjectName(flow);
-                const dependencies = this.getProjectDependencies(flowId, graph);
-                projects.push(this.generateProjectConfig(projectName, flow, dependencies));
-            });
-        });
-        const { areElementIdsVolatile, disableSelectorFailover, runInHeadedMode, slowMotionDelay, } = options;
-        const useConfig = {
-            screenshot: 'on',
-            video: 'on',
-            ...(runInHeadedMode && { headless: !runInHeadedMode }),
-            ...(slowMotionDelay &&
-                slowMotionDelay > 0 && { launchOptions: { slowMo: slowMotionDelay } }),
-        };
-        const selfHealingOptions = {
-            areElementIdsVolatile,
-            disableSelectorFailover,
-        };
-        const metadata = !options.disableSelfHealingTests
-            ? `metadata: ${JSON.stringify({ selfHealingOptions: selfHealingOptions }, null, 2)}`
-            : '';
-        const config = `import { defineConfig, devices } from 'donobu';
-
-export default defineConfig({
-  testDir: './tests',
-  projects: [ ${projects.join(',')} ],
-  use: ${JSON.stringify(useConfig, null, 2)},
-  reporter: [
-    ["github"],
-    ["json", { outputFile: "test-results/playwright-report.json" }],
-    ["html", { outputFolder: "playwright-report", open: "never" }],
-  ],
-  ${metadata}
-});`;
-        return this.prettifyCode(config);
-    }
-    /**
-     * Generates a single project configuration
-     */
-    generateProjectConfig(projectName, flow, dependencies) {
-        const minimumTimeoutMilliseconds = 30000;
-        const defaultTimeoutMilliseconds = 60000;
-        const calculatedTimeout = flow.startedAt && flow.completedAt
-            ? (flow.completedAt - flow.startedAt) * 2
-            : defaultTimeoutMilliseconds;
-        // Round up to the nearest 10000ms
-        const timeoutMilliseconds = Math.max(minimumTimeoutMilliseconds, Math.ceil(calculatedTimeout / 10000) * 10000);
-        const testMatch = `tests/${this.getTestFileName(flow)}`;
-        const deps = dependencies.length > 0
-            ? `\n      dependencies: [${dependencies.map((d) => `'${d}'`).join(', ')}],`
-            : '';
-        // Get device name from flow config, default to 'Desktop Chromium'
-        const deviceName = flow.browser?.using?.type === 'device'
-            ? flow.browser.using.deviceName || 'Desktop Chromium'
-            : 'Desktop Chromium';
-        return `{
-        name: '${projectName}',
-        testMatch: '${testMatch}',${deps}
-        use: { ...devices['${deviceName}'] },
-        timeout: ${timeoutMilliseconds}
-      }`;
-    }
-    /**
-     * Gets project dependencies for a given flow
-     */
-    getProjectDependencies(flowId, graph) {
-        const dependencies = graph.dependencies.get(flowId) || [];
-        return dependencies.map((depId) => {
-            const depFlow = graph.flows.get(depId);
-            return this.getProjectName(depFlow);
-        });
-    }
-    /**
-     * Generates test files for all flows
-     */
-    async generateTestFiles(flowsWithToolCalls) {
-        const files = [];
-        for (const { metadata, toolCalls } of flowsWithToolCalls) {
-            const fileName = this.getTestFileName(metadata);
-            const content = await this.getFlowAsPlaywrightScript(metadata, toolCalls);
-            files.push({
-                path: `tests/${fileName}`,
-                content,
-            });
-        }
-        return files;
-    }
-    /**
-     * Generates package.json
-     */
-    generatePackageJson() {
-        return JSON.stringify({
-            name: 'playwright-tests',
-            version: '1.0.0',
-            description: 'Playwright-based website tests made with Donobu',
-            scripts: {
-                test: 'npx playwright test',
-            },
-            devDependencies: {
-                donobu: 'latest',
-                playwright: PLAYWRIGHT_VERSION,
-                '@playwright/test': PLAYWRIGHT_VERSION,
-            },
-        }, null, 2);
-    }
-    /**
-     * Generates README.md
-     */
-    generateReadme() {
-        return `# Playwright Tests
-
-This project contains [Playwright](https://playwright.dev/)-based tests made with [Donobu](https://www.donobu.com/).
-
-## Installation
-
-Install project dependencies:
-
-\`\`\`bash
-npm install
-\`\`\`
-
-Install Playwright tooling (e.g. the web browsers for running tests)
-
-\`\`\`bash
-npx playwright install
-\`\`\`
-
-## Running Tests
-
-\`\`\`bash
-npx playwright test
-\`\`\`
-`;
-    }
-    /**
-     * Gets a project name for a flow
-     */
-    getProjectName(flow) {
-        if (flow.name) {
-            return flow.name.replace(/[^a-zA-Z0-9-_]/g, '-');
-        }
-        return `flow-${flow.id.substring(0, 8)}`;
-    }
-    /**
-     * Gets a test file name for a flow
-     */
-    getTestFileName(flow) {
-        const projectName = this.getProjectName(flow);
-        return `${projectName}.spec.ts`;
-    }
-    async prettifyCode(code) {
-        // Shenanigans way of importing prettier due to issues with Jest.
-        // See https://github.com/jestjs/jest/issues/14305
-        const prettier = require('prettier');
-        const formattedCode = prettier.format(code, {
-            parser: 'typescript',
-            semi: true,
-            singleQuote: true,
-        });
-        return formattedCode;
-    }
-    /**
-     * Sanitizes a JSON string to be safely used within a template literal (backtick string)
-     * Prevents both backtick termination and string interpolation from triggering
-     *
-     * @param jsonString - The JSON string to sanitize
-     * @returns The sanitized string that can be safely used within backticks
-     */
-    sanitizeForTemplateLiteral(jsonString) {
-        return (jsonString
-            // Escape backticks to prevent template literal termination
-            .replace(/`/g, '\\`')
-            // Escape ${...} patterns to prevent string interpolation
-            .replace(/\${/g, '\\${'));
-    }
-    isGptClientRequired(metadata, toolCalls, allTools) {
-        return (metadata.resultJsonSchema !== null ||
-            toolCalls
-                .map((toolCall) => {
-                return toolCall.name;
-            })
-                .map((toolCallName) => {
-                return allTools.find((t) => t.name === toolCallName);
-            })
-                .filter((tool) => {
-                return tool?.requiresGpt;
-            }).length > 0);
-    }
-    /**
-     * For tools that have a 'selector' argument, this function will serialize it
-     * to an appropriate call to the DonobuExtendedPage#find function.
-     */
-    parseFindCall(args) {
-        const selector = args.selector;
-        const [primarySelector, ...failover] = selector.element;
-        const frame = selector.frame;
-        const findOptions = {};
-        if (failover.length > 0) {
-            findOptions.failover = failover;
-        }
-        if (frame) {
-            findOptions.frame = frame;
-        }
-        // Build the page.find(...) call with 1 or 2 args depending on options presence.
-        const hasOptions = Object.keys(findOptions).length > 0;
-        const findCall = hasOptions
-            ? `await page.find(${JSON.stringify(primarySelector)}, ${JSON.stringify(findOptions)})`
-            : `await page.find(${JSON.stringify(primarySelector)})`;
-        return findCall;
-    }
-    /**
-     * Convert an *executed* list of {@link ToolCall}s into a list of
-     * {@link ProposedToolCall}s that can be replayed in a fresh browser
-     * session.
-     *
-     * ### What happens?
-     * 1. **Identify calls that need selector-remapping.**
-     *    Some tools (e.g. {@link ClickTool}, {@link InputTextTool}) rely on a
-     *    deterministic selector captured at runtime.  These tool names live in
-     *    `toolsThatNeedRemappedInputs`.
-     * 2. **Attempt remap with {@link ReplayableInteraction.prepareToolCallForRerun}.**
-     *    If a call belongs to that set, we delegate to
-     *    `ReplayableInteraction.remapForRerun` to inject the stored selector and
-     *    strip any transient GPT-only fields.
-     * 3. **Pass through other calls unchanged.**
-     *    Tools that have no UI footprint (e.g. navigation helpers, assertions)
-     *    are copied verbatim.
-     * 4. **Error handling.**
-     *    When remapping fails (e.g. selector metadata missing) we *skip* the
-     *    offending call, emit a warning via `appLogger`, and continue processing
-     *    the remainder so that a “best-effort” replay is still possible.
-     *
-     * The resulting array preserves the original order **minus** any calls that
-     * could not be remapped.
-     *
-     * @param toolCalls – The chronologically ordered list of executed
-     *                   {@link ToolCall}s.
-     * @returns A list of {@link ProposedToolCall}s ready for replay.
-     */
-    static async prepareToolCallsForRerun(toolCalls, options) {
-        // Tools that need special handling for their inputs during replay.
-        const toolsThatNeedRemappedInputs = new Set([
-            ChooseSelectOptionTool_1.ChooseSelectOptionTool.NAME,
-            ClickTool_1.ClickTool.NAME,
-            HoverOverElementTool_1.HoverOverElementTool.NAME,
-            InputRandomizedEmailAddressTool_1.InputRandomizedEmailAddressTool.NAME,
-            InputTextTool_1.InputTextTool.NAME,
-            PressKeyTool_1.PressKeyTool.NAME,
-            RememberPageTextTool_1.RememberPageTextTool.NAME,
-            ScrollPageTool_1.ScrollPageTool.NAME,
-        ]);
-        const proposedToolCalls = [];
-        for (const toolCall of toolCalls) {
-            const needsRemappedInputs = toolsThatNeedRemappedInputs.has(toolCall.toolName);
-            if (needsRemappedInputs) {
-                try {
-                    proposedToolCalls.push(ReplayableInteraction_1.ReplayableInteraction.prepareToolCallForRerun(toolCall, options));
-                }
-                catch (e) {
-                    // Skip.
-                    Logger_1.appLogger.warn(`Failed to prepare tool call for rerun: ${JSON.stringify(toolCall)}`, e);
-                }
-            }
-            else {
-                // This is just a normal tool then.
-                proposedToolCalls.push({
-                    name: toolCall.toolName,
-                    parameters: toolCall.parameters,
-                });
-            }
-        }
-        return proposedToolCalls;
-    }
-}
-exports.CodeGenerator = CodeGenerator;
-//# sourceMappingURL=CodeGenerator.js.map