donobu 3.4.0 → 3.5.0

package/dist/esm/codegen/CodeGenerator.js

@@ -0,0 +1,882 @@
+"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.CACHE_FILENAME = void 0;
+exports.getFlowAsPlaywrightScript = getFlowAsPlaywrightScript;
+exports.getFlowAsAiPlaywrightScript = getFlowAsAiPlaywrightScript;
+exports.generateProject = generateProject;
+exports.buildCacheContents = buildCacheContents;
+exports.convertProposedToolCallToPlaywrightCode = convertProposedToolCallToPlaywrightCode;
+exports.prettifyCode = prettifyCode;
+const fs = __importStar(require("fs"));
+const prettier_1 = require("prettier");
+const cache_1 = require("../lib/pageAi/cache");
+const cacheEntryBuilder_1 = require("../lib/pageAi/cacheEntryBuilder");
+const DonobuFlowsManager_1 = require("../managers/DonobuFlowsManager");
+const FlowDependencyAnalyzer_1 = require("../managers/FlowDependencyAnalyzer");
+const ToolManager_1 = require("../managers/ToolManager");
+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 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");
+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();
+// If you update the value of this constant, also update its references in the top-level README.md.
+exports.CACHE_FILENAME = 'cache-lock.js';
+/** Creates a Node.js Microsoft Playwright script to replay the given flow. */
+async function 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 gptClientRequired = isGptClientRequired(flowMetadata, toolCalls, allTools);
+    const gptSetupNote = gptClientRequired
+        ? `* 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: \`${sanitizeForTemplateLiteral(flowMetadata.overallObjective ?? '')}\`
+            },
+            ${envVarsAnnotations.join(',')}
+          ]
+        }`
+        : null;
+    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 convertProposedToolCallToPlaywrightCode(toolCall);
+    })
+        .join('\n\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';"
+        : ''}
+
+${testDetails ? 'const details = ' + testDetails : ''};
+test${testExtension}(${JSON.stringify(testName)}${testDetails ? ', details' : ''}, async ({ page }${flowMetadata.resultJsonSchema ? ', testInfo' : ''}) => {
+${scriptedToolCalls}
+${resultJson}
+});
+`;
+    return prettifyCode(script);
+}
+/** Creates a Node.js Microsoft Playwright script to replay the given flow. */
+async function getFlowAsAiPlaywrightScript(flowMetadata, toolCalls, options) {
+    const [firstToolCall, ...remaingToolCalls] = toolCalls;
+    // If the first tool call is "GoToWebpage", then we peel it off and treat it
+    // specially.
+    const specialCaseGoto = firstToolCall.name === GoToWebpageTool_1.GoToWebpageTool.NAME && remaingToolCalls.length > 0;
+    const gptSetupNote = ` * This test replays a recorded Donobu flow via \`page.act(...)\` using the cached
+ * tool calls stored alongside this spec in \`${exports.CACHE_FILENAME}\`. 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?.trim()
+        ? flowMetadata.overallObjective
+        : `Replay the recorded flow for ${flowMetadata.targetWebsite}`;
+    const sanitizedInstruction = sanitizeForTemplateLiteral(instructionSource);
+    const defaultToolNames = new Set((await ToolManager_1.ToolManager.defaultTools()).map((tool) => tool.name));
+    const minimalTools = new Set((await ToolManager_1.ToolManager.minimalTools()).map((t) => t.name));
+    const toolNamesFromCalls = Array.from(new Set((specialCaseGoto ? remaingToolCalls : toolCalls).map((tc) => tc.name)))
+        .filter((tc) => {
+        // We can exclude minimal tools since they will automatically be included
+        // when running any flow anyway, so no need to muck up the code by specifying them.
+        return !minimalTools.has(tc);
+    })
+        .sort();
+    const usesNonDefaultTool = toolNamesFromCalls.some((toolName) => !defaultToolNames.has(toolName));
+    const donobuImports = ['test'];
+    if (flowMetadata.resultJsonSchema !== null) {
+        donobuImports.push('jsonSchemaToZod');
+    }
+    if (useStorageState) {
+        donobuImports.push('getBrowserStorageStateFixture');
+    }
+    const optionsLines = [];
+    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 &&
+        flowMetadata.maxToolCalls !== DonobuFlowsManager_1.DonobuFlowsManager.DEFAULT_MAX_TOOL_CALLS) {
+        optionsLines.push(`maxToolCalls: ${flowMetadata.maxToolCalls}`);
+    }
+    if (flowMetadata.envVars && flowMetadata.envVars.length > 0) {
+        optionsLines.push(`envVars: ${JSON.stringify(flowMetadata.envVars)}`);
+    }
+    if (options?.areElementIdsVolatile) {
+        optionsLines.push(`volatileElementIds: true`);
+    }
+    if (options?.disableSelectorFailover) {
+        optionsLines.push(`noSelectorFailover: true`);
+    }
+    const aiOptionsLiteral = optionsLines.length > 0 ? `{${optionsLines.join(',')}}` : '';
+    const aiCallExpression = optionsLines.length > 0
+        ? `page.ai(\`${sanitizedInstruction}\`, ${aiOptionsLiteral})`
+        : `page.ai(\`${sanitizedInstruction}\`)`;
+    const needsTestInfo = flowMetadata.resultJsonSchema !== null;
+    const aiInvocation = needsTestInfo
+        ? `const extractedObj = await ${aiCallExpression};
+await testInfo.attach('extracted-object', { body: JSON.stringify(extractedObj, null, 2), contentType: 'application/json' });`
+        : `await ${aiCallExpression};`;
+    const gotoWebpage = specialCaseGoto
+        ? `await page.goto(${JSON.stringify(firstToolCall.parameters.url)});`
+        : '';
+    const preamble = `/**
+${gptSetupNote}*/`;
+    const script = `${preamble}
+import { ${donobuImports.join(',')} } from 'donobu';
+
+test${testExtension}('${testName}', async ({ page }${needsTestInfo ? ', testInfo' : ''}) => {
+${gotoWebpage}
+${aiInvocation}
+});
+`;
+    return prettifyCode(script);
+}
+/**
+ * Generates a complete Playwright project structure with dependency management.
+ */
+async function 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 generateTestFiles(flowsWithToolCalls, options);
+    files.push(...testFiles);
+    // Generate playwright.config.ts
+    files.push({
+        path: 'playwright.config.ts',
+        content: await generatePlaywrightConfig(dependencyGraph, options),
+    });
+    files.push({
+        path: '.github/workflows/run-tests.yml',
+        content: await generateGitHubActionsWorkflow(flowsWithToolCalls, gptConfig, options),
+    });
+    // Generate package.json if needed
+    files.push({
+        path: 'package.json',
+        content: generatePackageJson(),
+    });
+    // Generate README
+    files.push({
+        path: 'README.md',
+        content: generateReadme(),
+    });
+    files.push({
+        path: '.gitignore',
+        content: generateGitIgnore(),
+    });
+    const cacheFile = options.playwrightScriptVariant === 'ai'
+        ? await buildCacheFile(flowsWithToolCalls)
+        : undefined;
+    if (cacheFile) {
+        files.push(cacheFile);
+    }
+    return { files };
+}
+async function 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 gptClientRequired = flowsWithToolCalls.some((f) => {
+        return isGptClientRequired(f.metadata, f.toolCalls, allTools);
+    }) || !options.disableSelfHealingTests;
+    const envVarsList = [];
+    // The old version of self-healing uses an environment variable instead of
+    // a command-line argument to denote if tests should self-heal or not.
+    if (!options.disableSelfHealingTests &&
+        options.playwrightScriptVariant === 'classic') {
+        envVarsList.push('SELF_HEAL_TESTS_ENABLED: true');
+    }
+    if (gptClientRequired) {
+        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
+`
+        : '';
+    // The latest version of self-healing uses command-line arguments instead of
+    // an environment variable to denote if tests should self-heal or not.
+    const selfHealingSuffix = !options.disableSelfHealingTests && options.playwrightScriptVariant === 'ai'
+        ? ' --auto-heal'
+        : '';
+    const testCommand = options.runInHeadedMode
+        ? `xvfb-run -a npx donobu test${selfHealingSuffix}`
+        : `npx donobu test${selfHealingSuffix}`;
+    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}`;
+}
+function buildCacheContents(flowsWithToolCalls) {
+    const entries = flowsWithToolCalls
+        // We can only create page.ai caches for flows that have an objective.
+        .filter(({ metadata }) => metadata.overallObjective?.trim() && metadata.runMode === 'AUTONOMOUS')
+        .map(({ metadata, toolCalls }) => {
+        const [firstToolCall, ...remaingToolCalls] = toolCalls;
+        // If the first tool call is "GoToWebpage", then we peel it off and treat it
+        // specially (i.e. it will be an explicit tool call in the generated test file).
+        const specialCaseGoto = firstToolCall !== undefined &&
+            firstToolCall.name === GoToWebpageTool_1.GoToWebpageTool.NAME &&
+            remaingToolCalls.length > 0;
+        const toolCallsForCache = specialCaseGoto ? remaingToolCalls : toolCalls;
+        const cacheEntry = cacheEntryBuilder_1.PageAiCacheEntryBuilder.fromMetadata(metadata.targetWebsite, metadata, toolCallsForCache);
+        return {
+            ...cacheEntry,
+            allowedTools: [...cacheEntry.allowedTools],
+            schema: cacheEntry.schema === null
+                ? null
+                : JSON.parse(JSON.stringify(cacheEntry.schema)),
+        };
+    });
+    return {
+        caches: entries,
+    };
+}
+async function buildCacheFile(flowsWithToolCalls) {
+    if (flowsWithToolCalls.length === 0) {
+        return null;
+    }
+    const contents = buildCacheContents(flowsWithToolCalls);
+    const prettifiedJs = await prettifyCode((0, cache_1.renderCacheModule)(contents.caches));
+    return {
+        path: exports.CACHE_FILENAME,
+        content: prettifiedJs,
+    };
+}
+/**
+ * Maps a proposed Donobu tool call to valid NodeJS Playwright code that uses
+ * the `DonobuExtendedPage` extension.
+ */
+function 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 = parseFindCall(rawParams);
+            const { selector: _selector, optionValues } = rawParams;
+            return `${rationale}${find}.selectOption(${JSON.stringify(optionValues)})`;
+        }
+        case ClickTool_1.ClickTool.NAME: {
+            const find = 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 = parseFindCall(rawParams);
+            return `${rationale}${find}.hover()`;
+        }
+        case InputRandomizedEmailAddressTool_1.InputRandomizedEmailAddressTool.NAME: {
+            const find = parseFindCall(rawParams);
+            const { selector: _selector, baseEmail, finalizeWithSubmit: submit, } = rawParams;
+            return `${rationale}${find}.inputRandomizedEmailAddress(
+          ${JSON.stringify(baseEmail)},
+          ${submit ? JSON.stringify({ submit }) : ''})`;
+        }
+        case InputTextTool_1.InputTextTool.NAME: {
+            const find = parseFindCall(rawParams);
+            const { selector: _selector, text, append, finalizeWithSubmit: submit, } = rawParams;
+            const options = append === true || submit
+                ? JSON.stringify({
+                    ...(append === true ? { append } : {}),
+                    ...(submit ? { submit } : {}),
+                })
+                : '';
+            return `${rationale}${find}.inputText(
+          ${JSON.stringify(text)},
+          ${options})`;
+        }
+        case PressKeyTool_1.PressKeyTool.NAME: {
+            const find = 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 = 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;
+        }
+    }
+}
+function 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 function 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 = getProjectName(flow);
+            const dependencies = getProjectDependencies(flowId, graph);
+            projects.push(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 &&
+        options.playwrightScriptVariant === 'classic'
+        ? `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 prettifyCode(config);
+}
+/**
+ * Generates a single project configuration
+ */
+function 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/${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
+ */
+function getProjectDependencies(flowId, graph) {
+    const dependencies = graph.dependencies.get(flowId) || [];
+    return dependencies.map((depId) => {
+        const depFlow = graph.flows.get(depId);
+        return getProjectName(depFlow);
+    });
+}
+/**
+ * Generates test files for all flows
+ */
+async function generateTestFiles(flowsWithToolCalls, options) {
+    const files = [];
+    const scriptVariant = options.playwrightScriptVariant === 'classic' ? 'classic' : 'ai';
+    for (const { metadata, toolCalls } of flowsWithToolCalls) {
+        const fileName = getTestFileName(metadata);
+        const content = scriptVariant === 'classic' ||
+            !metadata.overallObjective?.trim() ||
+            metadata.runMode !== 'AUTONOMOUS'
+            ? await getFlowAsPlaywrightScript(metadata, toolCalls)
+            : await getFlowAsAiPlaywrightScript(metadata, toolCalls, options);
+        files.push({
+            path: `tests/${fileName}`,
+            content,
+        });
+    }
+    return files;
+}
+/**
+ * Generates package.json
+ */
+function 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
+ */
+function 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 donobu test
+\`\`\`
+`;
+}
+/**
+ * Gets a project name for a flow
+ */
+function getProjectName(flow) {
+    if (flow.name) {
+        return flow.name.replace(/[^a-zA-Z0-9-_]/g, '-');
+    }
+    else {
+        return `flow-${flow.id.substring(0, 8)}`;
+    }
+}
+/**
+ * Gets a test file name for a flow
+ */
+function getTestFileName(flow) {
+    const projectName = getProjectName(flow);
+    return `${projectName}.spec.ts`;
+}
+async function prettifyCode(code) {
+    const formattedCode = (0, prettier_1.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
+ */
+function sanitizeForTemplateLiteral(jsonString) {
+    return (jsonString
+        // Escape backticks to prevent template literal termination
+        .replace(/`/g, '\\`')
+        // Escape ${...} patterns to prevent string interpolation
+        .replace(/\${/g, '\\${'));
+}
+function 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.
+ */
+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;
+}
+//# sourceMappingURL=CodeGenerator.js.map