donobu 3.9.0 → 3.11.0

package/dist/codegen/runGenerateSiteTests.js

@@ -0,0 +1,923 @@
+#!/usr/bin/env ts-node
+"use strict";
+/**
+ * Library entrypoint for Donobu Site Test Generator (coverage-aware).
+ *
+ * Use `runGenerateSiteTests(options, onProgress?, shouldCancel?)` to invoke programmatically.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runGenerateSiteTests = runGenerateSiteTests;
+const node_url_1 = require("node:url");
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const slugify_1 = __importDefault(require("slugify"));
+const envVars_1 = require("../envVars");
+const DonobuStack_1 = require("../managers/DonobuStack");
+const BrowserStorageState_1 = require("../models/BrowserStorageState");
+const ControlPanel_1 = require("../models/ControlPanel");
+const EnvPersistenceVolatile_1 = require("../persistence/env/EnvPersistenceVolatile");
+const AnalyzePageTextTool_1 = require("../tools/AnalyzePageTextTool");
+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 DetectBrokenLinksTool_1 = require("../tools/DetectBrokenLinksTool");
+const GoForwardOrBackTool_1 = require("../tools/GoForwardOrBackTool");
+const GoToWebpageTool_1 = require("../tools/GoToWebpageTool");
+const HandleBrowserDialogTool_1 = require("../tools/HandleBrowserDialogTool");
+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 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 Logger_1 = require("../utils/Logger");
+const CodeGenerator_1 = require("./CodeGenerator");
+const DEFAULT_TEST_COUNT = 12;
+const DEFAULT_DISCOVERY_STEPS = 32;
+const DEFAULT_TEST_STEPS = 28;
+function snapshotEnv() {
+    const envRecord = {};
+    for (const [key, value] of Object.entries(process.env)) {
+        if (value !== undefined) {
+            envRecord[key] = value;
+        }
+    }
+    return envRecord;
+}
+async function loadStorageState(storageStatePath) {
+    if (!storageStatePath) {
+        return undefined;
+    }
+    const raw = await promises_1.default.readFile(storageStatePath, 'utf8');
+    const parsed = JSON.parse(raw);
+    return BrowserStorageState_1.BrowserStorageStateSchema.parse(parsed);
+}
+async function ensureGptAvailability(donobuStack, gptConfigName) {
+    const { gptClient } = await donobuStack.flowsManager.createGptClient(gptConfigName ?? undefined);
+    if (!gptClient) {
+        throw new Error('No GPT client is configured. Provide --gpt-config-name or set OPENAI_API_KEY / ANTHROPIC_API_KEY / GOOGLE_GENERATIVE_AI_API_KEY.');
+    }
+}
+async function waitForFlow(flowHandle, label, options, onProgress) {
+    const pollIntervalMs = options?.pollIntervalMs ?? 500;
+    let cancelled = false;
+    const checkCancelled = async () => {
+        if (cancelled || !options?.shouldCancel?.()) {
+            if (cancelled) {
+                throw new Error('Cancelled');
+            }
+            return;
+        }
+        cancelled = true;
+        onProgress?.({
+            type: 'log',
+            level: 'warn',
+            message: `Cancelling flow ${flowHandle.donobuFlow.metadata.id} (${label})`,
+        });
+        if (options?.onCancel) {
+            try {
+                await options.onCancel(flowHandle.donobuFlow.metadata.id);
+            }
+            catch (error) {
+                Logger_1.appLogger.warn(`Failed to cancel flow ${flowHandle.donobuFlow.metadata.id}`, error);
+            }
+        }
+        throw new Error('Cancelled');
+    };
+    const sleep = (ms) => new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+    Logger_1.appLogger.info(`waiting for ${label} (${flowHandle.donobuFlow.metadata.id}) to finish...`);
+    onProgress?.({
+        type: 'flow',
+        stage: 'start',
+        flowId: flowHandle.donobuFlow.metadata.id,
+        name: flowHandle.donobuFlow.metadata.name ?? label,
+    });
+    let stopWatching = false;
+    const cancelWatcher = (async () => {
+        while (!stopWatching) {
+            await sleep(pollIntervalMs);
+            await checkCancelled();
+        }
+    })();
+    try {
+        await checkCancelled();
+        await Promise.race([flowHandle.job, cancelWatcher]);
+        stopWatching = true;
+        await cancelWatcher.catch(() => { });
+        await checkCancelled();
+    }
+    catch (error) {
+        stopWatching = true;
+        await cancelWatcher.catch(() => { });
+        throw error;
+    }
+    const metadata = flowHandle.donobuFlow.metadata;
+    const allowedStates = options?.acceptStates ?? ['SUCCESS'];
+    if (!allowedStates.includes(metadata.state)) {
+        throw new Error(`Flow ${metadata.id} ended in state ${metadata.state}`);
+    }
+    onProgress?.({
+        type: 'flow',
+        stage: 'end',
+        flowId: flowHandle.donobuFlow.metadata.id,
+        name: metadata.name ?? label,
+    });
+    return metadata;
+}
+function buildAllowedTools(allowlist, denylist) {
+    const base = [
+        AnalyzePageTextTool_1.AnalyzePageTextTool.NAME,
+        ChangeWebBrowserTabTool_1.ChangeWebBrowserTabTool.NAME,
+        ChooseSelectOptionTool_1.ChooseSelectOptionTool.NAME,
+        ClickTool_1.ClickTool.NAME,
+        CreateBrowserCookieReportTool_1.CreateBrowserCookieReportTool.NAME,
+        DetectBrokenLinksTool_1.DetectBrokenLinksTool.NAME,
+        GoForwardOrBackTool_1.GoForwardOrBackTool.NAME,
+        GoToWebpageTool_1.GoToWebpageTool.NAME,
+        HandleBrowserDialogTool_1.HandleBrowserDialogTool.NAME,
+        HoverOverElementTool_1.HoverOverElementTool.NAME,
+        InputRandomizedEmailAddressTool_1.InputRandomizedEmailAddressTool.NAME,
+        InputTextTool_1.InputTextTool.NAME,
+        MakeCommentTool_1.MakeCommentTool.NAME,
+        MarkObjectiveCompleteTool_1.MarkObjectiveCompleteTool.NAME,
+        MarkObjectiveNotCompletableTool_1.MarkObjectiveNotCompletableTool.NAME,
+        PressKeyTool_1.PressKeyTool.NAME,
+        RememberPageTextTool_1.RememberPageTextTool.NAME,
+        RunAccessibilityTestTool_1.RunAccessibilityTestTool.NAME,
+        ScrollPageTool_1.ScrollPageTool.NAME,
+        SummarizeLearningsTool_1.SummarizeLearningsTool.NAME,
+        WaitTool_1.WaitTool.NAME,
+    ];
+    let tools = [...base];
+    if (allowlist && allowlist.length > 0) {
+        const set = new Set(allowlist);
+        tools = tools.filter((t) => set.has(t));
+    }
+    if (denylist && denylist.length > 0) {
+        const deny = new Set(denylist);
+        tools = tools.filter((t) => !deny.has(t));
+    }
+    return Array.from(new Set(tools));
+}
+function buildBrowserConfig(storageState, headed, persona) {
+    const baseConfig = {
+        using: {
+            type: 'device',
+            headless: !headed,
+        },
+        persistState: false,
+    };
+    if (!storageState || persona === 'guest') {
+        return baseConfig;
+    }
+    return {
+        ...baseConfig,
+        initialState: {
+            type: 'json',
+            value: storageState,
+        },
+    };
+}
+function buildDiscoveryObjective(targetUrl, maxTests, hasAuthState) {
+    const authLine = hasAuthState
+        ? 'Assume a valid signed-in storage state is preloaded; do not log out.'
+        : `If sign-in is required, keep exploring guest-accessible areas and mark tests that require auth.
+If blocked by auth, use the ${MarkObjectiveNotCompletableTool_1.MarkObjectiveNotCompletableTool.NAME} tool with a short note.`;
+    return `Profile ${targetUrl} to understand the product surface (ecommerce, SaaS, social, content, admin, etc.).
+Explore major journeys: onboarding/auth, primary conversion paths, search/browse, account/settings, support/help, and any admin areas.
+${authLine}
+
+While exploring, capture concise test ideas that can be run autonomously with Donobu tools. Prefer flows with clear assertions and business value.
+Aim for ${maxTests} high-signal, non-duplicative tests that span different page types and risk areas.
+Skip email-based verification loops and irreversible destructive actions.
+
+When ready, populate the JSON result and call ${MarkObjectiveCompleteTool_1.MarkObjectiveCompleteTool.NAME}.`;
+}
+function buildDiscoverySchema() {
+    return {
+        type: 'object',
+        properties: {
+            siteProfile: {
+                type: 'object',
+                properties: {
+                    siteType: { type: 'string' },
+                    primaryAudiences: { type: 'array', items: { type: 'string' } },
+                    requiresAuth: { type: 'boolean' },
+                    authNotes: { type: 'string' },
+                    keyJourneys: { type: 'array', items: { type: 'string' } },
+                    riskAreas: { type: 'array', items: { type: 'string' } },
+                },
+                required: [
+                    'siteType',
+                    'primaryAudiences',
+                    'requiresAuth',
+                    'keyJourneys',
+                    'riskAreas',
+                ],
+                additionalProperties: false,
+            },
+            testCases: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    properties: {
+                        title: { type: 'string' },
+                        objective: { type: 'string' },
+                        assertions: { type: 'array', items: { type: 'string' } },
+                        category: { type: 'string' },
+                        startUrl: { type: 'string' },
+                        dependsOnAuth: { type: 'boolean' },
+                        dataNeeds: { type: 'array', items: { type: 'string' } },
+                        priority: { type: 'string', enum: ['P0', 'P1', 'P2'] },
+                    },
+                    required: ['title', 'objective', 'assertions'],
+                    additionalProperties: false,
+                },
+            },
+        },
+        required: ['siteProfile', 'testCases'],
+        additionalProperties: false,
+    };
+}
+function buildTestObjective(testCase, persona, _siteProfile, coverageArea) {
+    const authLine = persona === 'auth'
+        ? 'A signed-in storage state is already loaded. Stay signed in; do not log out.'
+        : `Stay in a guest session. If authentication blocks progress, use ${MarkObjectiveNotCompletableTool_1.MarkObjectiveNotCompletableTool.NAME} with a one-line reason.`;
+    const assertions = testCase.assertions && testCase.assertions.length > 0
+        ? testCase.assertions.map((a) => `- ${a}`).join('\n')
+        : '- Record at least one clear assertion before finishing.';
+    const specialtyStep = coverageArea === 'accessibility'
+        ? 'Notes: After reaching the main assertion point, run runAccessibilityTest and note any critical violations.'
+        : coverageArea === 'links'
+            ? 'Notes: Run detectBrokenLinks (with screenshots if possible) and treat dead links as failures.'
+            : coverageArea === 'cookies'
+                ? 'Notes: Run createBrowserCookieReport and flag high-risk cookies in the assertion.'
+                : '';
+    return `Goal: ${testCase.title}
+Persona: ${authLine}
+Objective: ${testCase.objective}
+Assertions:
+${assertions}
+${specialtyStep ? `${specialtyStep}\n` : ''}Keep selectors stable, avoid redundant navigation, and finish by calling ${MarkObjectiveCompleteTool_1.MarkObjectiveCompleteTool.NAME} when assertions pass.`;
+}
+async function writeProject(projectDir, files) {
+    for (const file of files) {
+        const destination = path_1.default.join(projectDir, file.path);
+        await promises_1.default.mkdir(path_1.default.dirname(destination), { recursive: true });
+        await promises_1.default.writeFile(destination, file.content, 'utf8');
+    }
+}
+async function writePlanArtifacts(projectDir, discovery, selected) {
+    const planDir = path_1.default.join(projectDir, 'plan');
+    await promises_1.default.mkdir(planDir, { recursive: true });
+    await promises_1.default.writeFile(path_1.default.join(planDir, 'discovery.json'), JSON.stringify(discovery, null, 2), 'utf8');
+    await promises_1.default.writeFile(path_1.default.join(planDir, 'plan.json'), JSON.stringify(selected, null, 2), 'utf8');
+    const mdLines = [
+        '# Proposed Tests',
+        '',
+        `Site type: ${discovery.siteProfile.siteType}`,
+        `Requires auth: ${discovery.siteProfile.requiresAuth}`,
+        '',
+    ];
+    selected.forEach((tc, idx) => {
+        mdLines.push(`## ${idx + 1}. ${tc.title}`);
+        mdLines.push(tc.objective);
+        mdLines.push('');
+        mdLines.push(`- Persona: ${tc.persona}`);
+        mdLines.push(`- Coverage: ${tc.coverageArea}`);
+        mdLines.push(`- Source: ${tc.source}`);
+        if (tc.category) {
+            mdLines.push(`- Category: ${tc.category}`);
+        }
+        if (tc.priority) {
+            mdLines.push(`- Priority: ${tc.priority}`);
+        }
+        if (tc.assertions?.length) {
+            mdLines.push('Assertions:');
+            tc.assertions.forEach((a) => mdLines.push(`- ${a}`));
+            mdLines.push('');
+        }
+    });
+    await promises_1.default.writeFile(path_1.default.join(planDir, 'test-cases.md'), mdLines.join('\n'), 'utf8');
+}
+function matches(text, patterns) {
+    const lower = text.toLowerCase();
+    return patterns.some((p) => lower.includes(p));
+}
+function normalizeTitle(title) {
+    return title
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+async function loadExistingPlan(projectDir) {
+    try {
+        const planPath = path_1.default.join(projectDir, 'plan', 'plan.json');
+        const data = await promises_1.default.readFile(planPath, 'utf8');
+        const parsed = JSON.parse(data);
+        return parsed.map((p) => ({
+            ...p,
+            coverageArea: p.coverageArea ?? 'content',
+            persona: p.persona ?? 'guest',
+            source: p.source ?? 'discovery',
+        }));
+    }
+    catch (_e) {
+        return [];
+    }
+}
+async function pathExists(filepath) {
+    try {
+        await promises_1.default.access(filepath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function findProjectDir(projectSlug, userOut) {
+    const planExists = async (dir) => pathExists(path_1.default.join(dir, 'plan', 'plan.json'));
+    if (userOut) {
+        const base = path_1.default.resolve(userOut);
+        if (await planExists(base)) {
+            return base;
+        }
+        const candidate = path_1.default.join(base, `${projectSlug}-donobu-tests`);
+        return candidate;
+    }
+    const cwdDir = path_1.default.resolve(process.cwd());
+    if (await planExists(cwdDir)) {
+        return cwdDir;
+    }
+    return path_1.default.resolve('./out', `${projectSlug}-donobu-tests`);
+}
+function buildCatchAllPlaywrightConfig(options) {
+    const { runInHeadedMode, slowMotionDelay, areElementIdsVolatile, disableSelectorFailover, playwrightScriptVariant, disableSelfHealingTests, } = options;
+    const useConfig = {
+        screenshot: 'on',
+        video: 'on',
+        ...(runInHeadedMode && { headless: !runInHeadedMode }),
+        ...(slowMotionDelay &&
+            slowMotionDelay > 0 && { launchOptions: { slowMo: slowMotionDelay } }),
+    };
+    const selfHealingOptions = {
+        areElementIdsVolatile,
+        disableSelectorFailover,
+    };
+    const metadata = !disableSelfHealingTests && playwrightScriptVariant === 'classic'
+        ? `metadata: ${JSON.stringify({ selfHealingOptions: selfHealingOptions }, null, 2)}`
+        : '';
+    return `import { defineConfig, devices } from 'donobu';
+
+export default defineConfig({
+  testDir: './tests',
+  projects: [
+    {
+      name: 'all-tests',
+      testMatch: '**/*.spec.ts',
+      use: { ...devices['Desktop Chromium'] },
+      timeout: 60000
+    }
+  ],
+  use: ${JSON.stringify(useConfig, null, 2)},
+  reporter: [
+    ["github"],
+    ["json", { outputFile: "test-results/playwright-report.json" }],
+    ["html", { outputFolder: "playwright-report", open: "never" }]
+  ],
+  ${metadata}
+});`;
+}
+function pickPersona(testCase, hasAuthState, siteRequiresAuth) {
+    if (testCase.dependsOnAuth || siteRequiresAuth) {
+        return hasAuthState ? 'auth' : 'guest';
+    }
+    return 'guest';
+}
+function prioritize(testCases) {
+    const priorityRank = { P0: 0, P1: 1, P2: 2 };
+    return [...testCases].sort((a, b) => {
+        const pa = priorityRank[a.priority ?? 'P2'] ?? 3;
+        const pb = priorityRank[b.priority ?? 'P2'] ?? 3;
+        if (pa !== pb)
+            return pa - pb;
+        return (a.title || '').localeCompare(b.title || '');
+    });
+}
+function synthesizeTestCases(targetUrl, hasAuthState) {
+    return {
+        smoke: {
+            title: 'Homepage smoke and navigation',
+            objective: 'Open the homepage, verify the main hero/CTA is visible, and traverse primary navigation links without errors.',
+            assertions: [
+                'Hero heading and primary CTA are visible',
+                'Top navigation links route without errors',
+            ],
+            startUrl: targetUrl,
+            priority: 'P0',
+            category: 'Smoke',
+            dependsOnAuth: false,
+        },
+        auth: {
+            title: 'Authenticated session is honored',
+            objective: 'Confirm the provided storage state keeps the user signed in and can reach a personalized area (dashboard/profile).',
+            assertions: [
+                'User avatar/name or account menu is visible',
+                'A personalized page loads without redirect to login',
+            ],
+            startUrl: targetUrl,
+            priority: 'P0',
+            category: 'Authentication',
+            dependsOnAuth: hasAuthState,
+        },
+        navigation: {
+            title: 'Deep navigation path',
+            objective: 'Navigate through at least two levels of menus or breadcrumbs to a secondary page and verify page-specific content.',
+            assertions: [
+                'Second-level page loads without error',
+                'Breadcrumb or section header reflects the path',
+            ],
+            startUrl: targetUrl,
+            priority: 'P1',
+            category: 'Navigation',
+        },
+        search: {
+            title: 'Search or filtering flow',
+            objective: 'Execute a search or apply filters for a meaningful term and validate result relevance and empty states.',
+            assertions: [
+                'Results update based on query/filter',
+                'Empty state message appears for a nonsense query',
+            ],
+            startUrl: targetUrl,
+            priority: 'P1',
+            category: 'Search',
+        },
+        forms: {
+            title: 'Form submission with validation',
+            objective: 'Complete a representative form (contact/signup/checkout) including both valid and invalid data paths, observing validation messages.',
+            assertions: [
+                'Invalid input triggers inline validation',
+                'Valid submission yields success toast or confirmation',
+            ],
+            startUrl: targetUrl,
+            priority: 'P1',
+            category: 'Forms',
+        },
+        checkout: {
+            title: 'Cart/checkout happy path',
+            objective: 'Add an item to cart (or equivalent action) and progress through checkout/confirmation until a stable success indicator.',
+            assertions: [
+                'Cart count increments',
+                'Order/confirmation or review page shows totals',
+            ],
+            startUrl: targetUrl,
+            priority: 'P0',
+            category: 'Checkout',
+        },
+        content: {
+            title: 'Content/detail page integrity',
+            objective: 'Open a representative detail page (product/article/profile) and verify key metadata, media, and links render correctly.',
+            assertions: [
+                'Title and key metadata visible',
+                'Primary media loads (image/video)',
+            ],
+            startUrl: targetUrl,
+            priority: 'P2',
+            category: 'Content',
+        },
+        accessibility: {
+            title: 'Accessibility scan on homepage',
+            objective: 'Run an axe-core accessibility scan on the homepage and summarize any violations.',
+            assertions: [
+                'Accessibility scan completes',
+                'No critical violations remain unresolved',
+            ],
+            startUrl: targetUrl,
+            priority: 'P1',
+            category: 'Accessibility',
+        },
+        links: {
+            title: 'Dead links check on homepage',
+            objective: 'Detect broken links on the homepage and capture evidence for any dead or redirected links.',
+            assertions: ['No dead links on homepage', 'Redirect chains are healthy'],
+            startUrl: targetUrl,
+            priority: 'P1',
+            category: 'Links',
+        },
+        cookies: {
+            title: 'Cookie and storage audit',
+            objective: 'Collect a cookie/storage report and call out any high-risk cookies (insecure, cross-site, long-lived).',
+            assertions: [
+                'Report includes cookies and storage entries',
+                'High-risk cookies are identified',
+            ],
+            startUrl: targetUrl,
+            priority: 'P2',
+            category: 'Cookies',
+        },
+    };
+}
+function matchesCoverage(testCase, area) {
+    const text = `${testCase.title ?? ''} ${testCase.objective ?? ''}`.toLowerCase();
+    switch (area) {
+        case 'smoke':
+            return matches(text, [
+                'home',
+                'landing',
+                'nav',
+                'navigation',
+                'dashboard',
+            ]);
+        case 'auth':
+            return matches(text, ['login', 'sign in', 'auth', 'session']);
+        case 'navigation':
+            return matches(text, ['navigate', 'navigation', 'menu', 'breadcrumb']);
+        case 'search':
+            return matches(text, ['search', 'filter', 'browse', 'query']);
+        case 'forms':
+            return matches(text, ['form', 'submit', 'validation', 'input']);
+        case 'checkout':
+            return matches(text, ['cart', 'checkout', 'order', 'payment']);
+        case 'content':
+            return matches(text, ['detail', 'article', 'product', 'profile']);
+        case 'accessibility':
+            return matches(text, ['accessibility', 'a11y', 'axe']);
+        case 'links':
+            return matches(text, ['link', 'broken link', '404', 'dead link']);
+        case 'cookies':
+            return matches(text, ['cookie', 'storage', 'privacy']);
+        default:
+            return false;
+    }
+}
+function curateTestPlan(discovery, targetUrl, maxTests, hasAuthState, existingPlan = []) {
+    const prioritized = prioritize(discovery.testCases);
+    const used = new Set();
+    const synthesized = synthesizeTestCases(targetUrl, hasAuthState);
+    const existingTitles = new Set(existingPlan.map((p) => normalizeTitle(p.title ?? '')));
+    const existingCoverage = existingPlan.reduce((acc, p) => {
+        const area = p.coverageArea ?? 'content';
+        acc[area] = (acc[area] ?? 0) + 1;
+        return acc;
+    }, {
+        smoke: 0,
+        auth: 0,
+        navigation: 0,
+        search: 0,
+        forms: 0,
+        checkout: 0,
+        content: 0,
+        accessibility: 0,
+        links: 0,
+        cookies: 0,
+    });
+    const coverageOrder = [
+        {
+            area: 'smoke',
+            mandatory: existingCoverage.smoke === 0,
+            synthesize: true,
+            persona: 'guest',
+        },
+        {
+            area: 'auth',
+            mandatory: (discovery.siteProfile.requiresAuth || hasAuthState) &&
+                existingCoverage.auth === 0,
+            synthesize: hasAuthState,
+            persona: 'auth',
+        },
+        {
+            area: 'navigation',
+            mandatory: existingCoverage.navigation === 0,
+            synthesize: true,
+            persona: 'auto',
+        },
+        {
+            area: 'search',
+            mandatory: existingCoverage.search === 0,
+            synthesize: true,
+            persona: 'auto',
+        },
+        {
+            area: 'forms',
+            mandatory: existingCoverage.forms === 0,
+            synthesize: true,
+            persona: 'auto',
+        },
+        {
+            area: 'checkout',
+            mandatory: existingCoverage.checkout === 0,
+            synthesize: true,
+            persona: 'auto',
+        },
+        {
+            area: 'content',
+            mandatory: existingCoverage.content === 0,
+            synthesize: true,
+            persona: 'auto',
+        },
+        {
+            area: 'links',
+            mandatory: existingCoverage.links === 0,
+            synthesize: true,
+            persona: 'guest',
+        },
+        {
+            area: 'accessibility',
+            mandatory: existingCoverage.accessibility === 0,
+            synthesize: true,
+            persona: 'guest',
+        },
+        {
+            area: 'cookies',
+            mandatory: existingCoverage.cookies === 0,
+            synthesize: true,
+            persona: 'auto',
+        },
+    ];
+    const planned = [];
+    const takeCase = (area, personaHint) => {
+        for (let i = 0; i < prioritized.length; i++) {
+            if (used.has(i))
+                continue;
+            const candidate = prioritized[i];
+            if (existingTitles.has(normalizeTitle(candidate.title ?? '')))
+                continue;
+            if (!matchesCoverage(candidate, area))
+                continue;
+            used.add(i);
+            const persona = personaHint === 'auto'
+                ? pickPersona(candidate, hasAuthState, discovery.siteProfile.requiresAuth)
+                : personaHint;
+            return { ...candidate, coverageArea: area, persona, source: 'discovery' };
+        }
+        return null;
+    };
+    for (const coverage of coverageOrder) {
+        if (planned.length >= maxTests)
+            break;
+        const picked = takeCase(coverage.area, coverage.persona);
+        if (picked) {
+            planned.push(picked);
+            continue;
+        }
+        if (coverage.synthesize &&
+            (coverage.mandatory || planned.length < maxTests)) {
+            const synth = synthesized[coverage.area];
+            planned.push({
+                ...synth,
+                coverageArea: coverage.area,
+                persona: coverage.persona === 'auto'
+                    ? pickPersona(synth, hasAuthState, discovery.siteProfile.requiresAuth)
+                    : coverage.persona,
+                source: 'synthetic',
+            });
+        }
+    }
+    for (let i = 0; i < prioritized.length && planned.length < maxTests; i++) {
+        if (used.has(i))
+            continue;
+        const candidate = prioritized[i];
+        if (existingTitles.has(normalizeTitle(candidate.title ?? '')))
+            continue;
+        planned.push({
+            ...candidate,
+            coverageArea: 'content',
+            persona: pickPersona(candidate, hasAuthState, discovery.siteProfile.requiresAuth),
+            source: 'discovery',
+        });
+    }
+    return planned.slice(0, maxTests);
+}
+function formatFlowName(title, coverageArea, persona) {
+    const parts = [title];
+    if (coverageArea) {
+        parts.push(`[${coverageArea}]`);
+    }
+    if (persona) {
+        parts.push(`(${persona})`);
+    }
+    const combined = parts.join(' ').replace(/\s+/g, ' ').trim();
+    const sanitized = combined
+        .replace(/[^a-zA-Z0-9-_ ()[\]]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/-+$/, '')
+        .replace(/^-+/, '')
+        .trim();
+    const truncated = sanitized.length > 240 ? sanitized.slice(0, 240) : sanitized;
+    return truncated || 'Donobu Flow';
+}
+async function runGenerateSiteTests(opts, onProgress, shouldCancel) {
+    const { url, outDir, storageStatePath, maxTests = DEFAULT_TEST_COUNT, maxDiscoverySteps = DEFAULT_DISCOVERY_STEPS, maxTestSteps = DEFAULT_TEST_STEPS, gptConfigName, playwrightVariant = 'ai', headed = false, slowMo, disableSelfHeal = false, toolAllowlist, toolDenylist, } = opts;
+    const assertNotCancelled = (stage) => {
+        if (shouldCancel?.()) {
+            onProgress?.({
+                type: 'log',
+                level: 'warn',
+                message: `Cancelled during ${stage}`,
+            });
+            throw new Error('Cancelled');
+        }
+    };
+    assertNotCancelled('initialization');
+    const targetUrl = new node_url_1.URL(url).toString();
+    const projectSlug = (0, slugify_1.default)(new node_url_1.URL(targetUrl).hostname, {
+        lower: true,
+        strict: true,
+    });
+    const projectDir = await findProjectDir(projectSlug, outDir);
+    await promises_1.default.mkdir(projectDir, { recursive: true });
+    const existingPlan = await loadExistingPlan(projectDir);
+    assertNotCancelled('pre-flight setup');
+    Logger_1.appLogger.info(`📍 Target: ${targetUrl}`);
+    if (storageStatePath) {
+        Logger_1.appLogger.info('🔐 Using provided storage state for logged-in flows');
+    }
+    else {
+        Logger_1.appLogger.info('🧭 No storage state provided; tests that require auth will be marked accordingly');
+    }
+    onProgress?.({
+        type: 'log',
+        level: 'info',
+        message: `Target ${targetUrl}; out ${projectDir}`,
+    });
+    if (toolAllowlist?.length || toolDenylist?.length) {
+        onProgress?.({
+            type: 'log',
+            level: 'info',
+            message: `Tool filters applied (allowlist: ${toolAllowlist?.join(', ') || 'none'}, denylist: ${toolDenylist?.join(', ') || 'none'})`,
+        });
+    }
+    const storageState = await loadStorageState(storageStatePath);
+    assertNotCancelled('loading storage state');
+    const donobuStack = await (0, DonobuStack_1.setupDonobuStack)('LOCAL', ControlPanel_1.NoOpControlPanelFactory, new EnvPersistenceVolatile_1.EnvPersistenceVolatile(snapshotEnv()), envVars_1.env.pick('ANTHROPIC_API_KEY', 'ANTHROPIC_MODEL_NAME', 'AWS_ACCESS_KEY_ID', 'AWS_BEDROCK_MODEL_NAME', 'AWS_REGION', 'AWS_S3_BUCKET', 'AWS_S3_REGION', 'AWS_SECRET_ACCESS_KEY', 'BASE64_GPT_CONFIG', 'BROWSERBASE_API_KEY', 'BROWSERBASE_PROJECT_ID', 'DONOBU_API_KEY', 'GOOGLE_GENERATIVE_AI_API_KEY', 'GOOGLE_GENERATIVE_AI_MODEL_NAME', 'GOOGLE_CLOUD_STORAGE_BUCKET', 'OPENAI_API_KEY', 'OPENAI_API_MODEL_NAME', 'SUPABASE_JWT_SECRET_KEY'));
+    await ensureGptAvailability(donobuStack, gptConfigName);
+    assertNotCancelled('ensuring GPT availability');
+    const allowedTools = buildAllowedTools(toolAllowlist, toolDenylist);
+    onProgress?.({
+        type: 'log',
+        level: 'info',
+        message: `Enabled tools: ${allowedTools.join(', ')}`,
+    });
+    const discoveryFlow = await donobuStack.flowsManager.createFlow({
+        targetWebsite: targetUrl,
+        overallObjective: buildDiscoveryObjective(targetUrl, maxTests, Boolean(storageState)),
+        name: formatFlowName(`Discovery for ${targetUrl}`),
+        allowedTools,
+        maxToolCalls: maxDiscoverySteps,
+        initialRunMode: 'AUTONOMOUS',
+        resultJsonSchema: buildDiscoverySchema(),
+        browser: buildBrowserConfig(storageState, headed, storageState ? 'auth' : 'guest'),
+        gptConfigNameOverride: gptConfigName ?? null,
+        videoDisabled: true,
+    });
+    let discoveryMetadata = null;
+    try {
+        discoveryMetadata = await waitForFlow(discoveryFlow, 'discovery flow', {
+            acceptStates: ['SUCCESS', 'FAILED'],
+            shouldCancel,
+            onCancel: async (flowId) => {
+                await donobuStack.flowsManager.cancelFlow(flowId);
+            },
+        }, onProgress);
+    }
+    catch (error) {
+        Logger_1.appLogger.error('Failed to complete discovery flow', error);
+        onProgress?.({
+            type: 'log',
+            level: 'error',
+            message: `Discovery failed: ${error.message}`,
+        });
+        discoveryMetadata = null;
+    }
+    if (discoveryMetadata?.state === 'FAILED') {
+        Logger_1.appLogger.warn(`Discovery flow ended in state FAILED; continuing with synthesized tests and any partial data.`);
+    }
+    let discoveryResult = discoveryMetadata?.result ?? null;
+    if (!discoveryResult || !discoveryResult.testCases?.length) {
+        Logger_1.appLogger.warn('Discovery flow did not return any test cases; synthesizing baseline coverage.');
+        discoveryResult = {
+            siteProfile: {
+                siteType: 'Unknown',
+                primaryAudiences: [],
+                requiresAuth: Boolean(storageState),
+                keyJourneys: [],
+                riskAreas: [],
+            },
+            testCases: [],
+        };
+    }
+    if (discoveryResult.siteProfile.requiresAuth && !storageState) {
+        onProgress?.({
+            type: 'log',
+            level: 'warn',
+            message: 'Site appears to require authentication; no storage state provided. Auth journeys may be incomplete.',
+        });
+    }
+    const selectedTestCases = curateTestPlan(discoveryResult, targetUrl, maxTests, Boolean(storageState), existingPlan);
+    const mergedPlan = [...existingPlan, ...selectedTestCases];
+    await writePlanArtifacts(projectDir, discoveryResult, mergedPlan);
+    assertNotCancelled('writing plan artifacts');
+    const successfulFlowIds = [];
+    const flowAnnotationsMap = {};
+    for (const testCase of selectedTestCases) {
+        assertNotCancelled(`starting flow for ${testCase.title}`);
+        Logger_1.appLogger.info(`🧪 Running test flow: ${testCase.title} (${testCase.coverageArea}, ${testCase.persona})`);
+        onProgress?.({
+            type: 'log',
+            level: 'info',
+            message: `Running test: ${testCase.title}`,
+        });
+        const startUrl = testCase.startUrl || targetUrl;
+        const testFlow = await donobuStack.flowsManager.createFlow({
+            targetWebsite: startUrl,
+            overallObjective: buildTestObjective(testCase, testCase.persona, discoveryResult.siteProfile, testCase.coverageArea),
+            name: formatFlowName(testCase.title, testCase.coverageArea, testCase.persona),
+            allowedTools,
+            maxToolCalls: maxTestSteps,
+            initialRunMode: 'AUTONOMOUS',
+            browser: buildBrowserConfig(storageState, headed, testCase.persona),
+            gptConfigNameOverride: gptConfigName ?? null,
+            videoDisabled: true,
+            toolCallsOnStart: [
+                {
+                    name: GoToWebpageTool_1.GoToWebpageTool.NAME,
+                    parameters: {
+                        url: startUrl,
+                    },
+                },
+            ],
+        });
+        try {
+            const metadata = await waitForFlow(testFlow, testCase.title, {
+                shouldCancel,
+                onCancel: async (flowId) => {
+                    await donobuStack.flowsManager.cancelFlow(flowId);
+                },
+            }, onProgress);
+            flowAnnotationsMap[metadata.id] = [
+                { type: 'coverage', description: testCase.coverageArea },
+                { type: 'persona', description: testCase.persona },
+                { type: 'priority', description: testCase.priority ?? 'unspecified' },
+                { type: 'category', description: testCase.category ?? 'unspecified' },
+            ];
+            successfulFlowIds.push(metadata.id);
+        }
+        catch (error) {
+            Logger_1.appLogger.error(`Test flow failed for "${testCase.title}"`, error);
+            onProgress?.({
+                type: 'log',
+                level: 'error',
+                message: `Test flow failed for "${testCase.title}": ${error.message}`,
+            });
+        }
+    }
+    if (successfulFlowIds.length === 0) {
+        throw new Error('No test flows completed successfully; nothing to generate');
+    }
+    const codegenOptions = {
+        playwrightScriptVariant: playwrightVariant,
+        disableSelfHealingTests: disableSelfHeal,
+        runInHeadedMode: headed,
+        ...(slowMo !== undefined ? { slowMotionDelay: slowMo } : {}),
+        flowAnnotations: flowAnnotationsMap,
+    };
+    const project = await donobuStack.flowsManager.getFlowsAsPlaywrightProject(successfulFlowIds, codegenOptions);
+    assertNotCancelled('building playwright project');
+    await writeProject(projectDir, project.files);
+    if (existingPlan.length > 0) {
+        const catchAllConfig = await (0, CodeGenerator_1.prettifyCode)(buildCatchAllPlaywrightConfig(codegenOptions));
+        assertNotCancelled('writing Playwright config');
+        await promises_1.default.writeFile(path_1.default.join(projectDir, 'playwright.config.ts'), catchAllConfig, 'utf8');
+    }
+    onProgress?.({
+        type: 'summary',
+        data: {
+            projectDir,
+            newlyGeneratedTests: successfulFlowIds.length,
+            totalPlannedTests: mergedPlan.length,
+            requiresAuth: discoveryResult.siteProfile.requiresAuth,
+            usedStorageState: Boolean(storageState),
+            siteProfile: discoveryResult.siteProfile,
+        },
+    });
+    Logger_1.appLogger.info(`✅ Generated Playwright project in ${projectDir}`);
+    onProgress?.({
+        type: 'log',
+        level: 'info',
+        message: `Generated project in ${projectDir}`,
+    });
+    Logger_1.appLogger.info(`ℹ️  Install deps with "npm install" then run tests with "npx donobu test" (or "npx donobu test --auto-heal").`);
+}
+//# sourceMappingURL=runGenerateSiteTests.js.map