@nhonh/qabot 0.5.1 → 0.6.0

package/bin/qabot.js

@@ -8,6 +8,7 @@ import { registerListCommand } from "../src/cli/commands/list.js";
 import { registerGenerateCommand } from "../src/cli/commands/generate.js";
 import { registerReportCommand } from "../src/cli/commands/report.js";
 import { registerAuthCommand } from "../src/cli/commands/auth.js";
+import { registerTestCommand } from "../src/cli/commands/test.js";
 
 const program = new Command();
 
@@ -18,6 +19,7 @@ program
 
 registerInitCommand(program);
 registerRunCommand(program);
+registerTestCommand(program);
 registerListCommand(program);
 registerGenerateCommand(program);
 registerReportCommand(program);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nhonh/qabot",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "AI-powered universal QA automation tool. Import any project, AI analyzes and runs tests across all layers.",
   "main": "src/index.js",
   "bin": {

package/src/cli/commands/test.js

@@ -0,0 +1,466 @@
+import chalk from "chalk";
+import ora from "ora";
+import path from "node:path";
+import { writeFile, readFile } from "node:fs/promises";
+import { execSync } from "node:child_process";
+import { logger } from "../../core/logger.js";
+import { loadConfig } from "../../core/config.js";
+import { analyzeProject } from "../../analyzers/project-analyzer.js";
+import { AIEngine } from "../../ai/ai-engine.js";
+import { UseCaseParser } from "../../ai/usecase-parser.js";
+import {
+  ensurePlaywright,
+  ensureE2EStructure,
+  writePlaywrightConfig,
+  writeAuthHelper,
+} from "../../e2e/playwright-setup.js";
+import { generateE2ESpec, fixE2ESpec } from "../../e2e/e2e-generator.js";
+import {
+  findFiles,
+  safeReadFile,
+  ensureDir,
+  fileExists,
+} from "../../utils/file-utils.js";
+import { ReportGenerator } from "../../reporter/report-generator.js";
+
+const MAX_FIX_ATTEMPTS = 3;
+
+export function registerTestCommand(program) {
+  program
+    .command("test [feature]")
+    .description("Run E2E automation tests (Playwright)")
+    .option("-e, --env <environment>", "Target environment", "default")
+    .option("--headed", "Run browser in headed mode (visible)")
+    .option("--no-fix", "Skip auto-fix on failure")
+    .option("--skip-gen", "Skip test generation, run existing specs only")
+    .option("--use-cases <dir>", "Directory containing use case documents")
+    .option("--model <model>", "AI model to use")
+    .option("-d, --dir <path>", "Project directory", process.cwd())
+    .action(runTest);
+}
+
+async function runTest(feature, options) {
+  const projectDir = options.dir;
+  const { config, isEmpty } = await loadConfig(projectDir);
+
+  if (isEmpty) {
+    logger.warn("No qabot.config.json found. Run `qabot init` first.");
+    return;
+  }
+
+  const profile = await analyzeProject(projectDir);
+  const envConfig =
+    config.environments?.[options.env] || config.environments?.default;
+  const baseUrl = envConfig?.url || "http://localhost:3000";
+
+  logger.header("QABot \u2014 E2E Automation Test");
+  logger.blank();
+  logger.info(`Feature:     ${chalk.bold(feature || "all")}`);
+  logger.info(`Target:      ${chalk.bold.cyan(baseUrl)}`);
+  logger.info(`Environment: ${chalk.bold(options.env)}`);
+  logger.info(
+    `Browser:     ${options.headed ? "Headed (visible)" : "Headless"}`,
+  );
+  logger.blank();
+  console.log(chalk.dim(`  ${"\u2500".repeat(50)}`));
+
+  const spinner = ora("Setting up Playwright...").start();
+  try {
+    await ensurePlaywright(projectDir);
+    await ensureE2EStructure(projectDir);
+    await writePlaywrightConfig(projectDir, config);
+    await writeAuthHelper(projectDir, config);
+    spinner.succeed("Playwright ready");
+  } catch (err) {
+    spinner.fail(`Playwright setup failed: ${err.message}`);
+    return;
+  }
+
+  const featureConfig = feature ? config.features?.[feature] : null;
+  const specDir = path.join(projectDir, "e2e", "tests");
+  let specFile;
+
+  if (options.skipGen) {
+    const existing = await findFiles(specDir, "*.spec.js");
+    if (existing.length === 0) {
+      logger.error(
+        "No existing E2E specs found. Run without --skip-gen to generate.",
+      );
+      return;
+    }
+    specFile = feature
+      ? existing.find((f) => f.toLowerCase().includes(feature.toLowerCase()))
+      : null;
+    logger.info(
+      `Running ${specFile ? path.basename(specFile) : "all"} existing specs`,
+    );
+  } else {
+    if (!feature) {
+      logger.error(
+        "Feature name required for test generation. Usage: qabot test <feature>",
+      );
+      return;
+    }
+
+    const aiConfig = { ...config.ai };
+    if (options.model) aiConfig.model = options.model;
+    const ai = new AIEngine(aiConfig);
+
+    if (!ai.isAvailable()) {
+      logger.error("AI not configured. Run `qabot auth` first.");
+      return;
+    }
+
+    const spinner2 = ora(
+      "AI is analyzing feature and generating E2E tests...",
+    ).start();
+
+    let sourceCode = "";
+    if (featureConfig?.src) {
+      const sourceFiles = await findFiles(
+        projectDir,
+        `${featureConfig.src}/**/*.{js,jsx,ts,tsx}`,
+      );
+      const filtered = sourceFiles.filter(
+        (f) => !f.includes("/tests/") && !f.includes(".test."),
+      );
+      sourceCode = (
+        await Promise.all(filtered.slice(0, 8).map((f) => safeReadFile(f)))
+      )
+        .filter(Boolean)
+        .join("\n\n---\n\n");
+    }
+
+    let useCases = [];
+    const useCaseDir = options.useCases || config.useCases?.dir;
+    if (useCaseDir) {
+      const parser = new UseCaseParser();
+      const ucFiles = await findFiles(
+        projectDir,
+        `${useCaseDir}/**/*.{md,feature,txt}`,
+      );
+      for (const f of ucFiles) {
+        try {
+          useCases.push(...(await parser.parse(f)));
+        } catch {
+          /* skip */
+        }
+      }
+    }
+
+    const route = featureConfig?.route || guessRoute(feature);
+
+    try {
+      const spec = await generateE2ESpec(ai, feature, {
+        baseUrl,
+        sourceCode,
+        route,
+        authProvider: config.auth?.provider || "none",
+        useCases,
+      });
+
+      specFile = path.join(specDir, `${feature}.spec.js`);
+      await writeFile(specFile, spec, "utf-8");
+      spinner2.succeed(
+        `E2E spec generated: ${chalk.underline(path.relative(projectDir, specFile))}`,
+      );
+    } catch (err) {
+      spinner2.fail(`E2E generation failed: ${err.message}`);
+      return;
+    }
+
+    if (options.fix !== false) {
+      const aiForFix = ai;
+
+      for (let attempt = 1; attempt <= MAX_FIX_ATTEMPTS; attempt++) {
+        logger.blank();
+        logger.step(
+          attempt,
+          MAX_FIX_ATTEMPTS,
+          `Running E2E tests (attempt ${attempt})...`,
+        );
+
+        const {
+          exitCode,
+          error: testError,
+          stdout,
+        } = runPlaywright(projectDir, specFile, options);
+
+        if (exitCode === 0) {
+          printPlaywrightSummary(stdout);
+          logger.blank();
+          logger.success(`E2E tests passed on attempt ${attempt}!`);
+          await generateE2EReport(
+            projectDir,
+            config,
+            feature,
+            options.env,
+            baseUrl,
+          );
+          return;
+        }
+
+        if (attempt >= MAX_FIX_ATTEMPTS) {
+          printPlaywrightSummary(stdout || testError);
+          logger.blank();
+          logger.warn(
+            `E2E tests still failing after ${MAX_FIX_ATTEMPTS} attempts.`,
+          );
+          logger.dim(`  Review: cat ${path.relative(projectDir, specFile)}`);
+          logger.dim(`  Debug:  qabot test ${feature} --headed`);
+          await generateE2EReport(
+            projectDir,
+            config,
+            feature,
+            options.env,
+            baseUrl,
+          );
+          return;
+        }
+
+        logger.dim(`  ${extractFirstError(testError || stdout)}`);
+        logger.step(attempt, MAX_FIX_ATTEMPTS, "AI is fixing E2E test...");
+
+        try {
+          const currentCode = await readFile(specFile, "utf-8");
+          const fixedCode = await fixE2ESpec(
+            aiForFix,
+            currentCode,
+            testError || stdout,
+            {
+              baseUrl,
+              authProvider: config.auth?.provider,
+            },
+          );
+          await writeFile(specFile, fixedCode, "utf-8");
+          logger.dim("  Fix applied. Re-running...");
+        } catch (err) {
+          logger.warn(`  AI fix failed: ${err.message}`);
+          break;
+        }
+      }
+    }
+  }
+
+  if (!specFile && !options.skipGen) return;
+
+  logger.blank();
+  logger.info("Running E2E tests...");
+
+  const {
+    exitCode,
+    stdout,
+    error: testError,
+  } = runPlaywright(projectDir, specFile, options);
+  printPlaywrightSummary(stdout || testError);
+  await generateE2EReport(
+    projectDir,
+    config,
+    feature || "all",
+    options.env,
+    baseUrl,
+  );
+
+  if (exitCode !== 0) process.exit(1);
+}
+
+function runPlaywright(projectDir, specFile, options) {
+  const configPath = path.join(projectDir, "e2e", "playwright.config.js");
+  const parts = ["npx", "playwright", "test"];
+  if (specFile)
+    parts.push(path.relative(path.join(projectDir, "e2e"), specFile));
+  parts.push(`--config="${configPath}"`);
+  parts.push("--project=chromium");
+  if (options.headed) parts.push("--headed");
+
+  const env = {
+    ...process.env,
+    E2E_ENV: options.env || "default",
+    FORCE_COLOR: "0",
+  };
+
+  try {
+    const stdout = execSync(parts.join(" "), {
+      cwd: projectDir,
+      stdio: "pipe",
+      timeout: 120000,
+      env,
+    }).toString();
+    return { exitCode: 0, stdout, error: "" };
+  } catch (err) {
+    return {
+      exitCode: err.status || 1,
+      stdout: err.stdout?.toString() || "",
+      error: err.stderr?.toString() || err.stdout?.toString() || "",
+    };
+  }
+}
+
+function printPlaywrightSummary(output) {
+  if (!output) return;
+  const lines = output.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (trimmed.includes("\u2713") || trimmed.includes("passed")) {
+      logger.success(trimmed);
+    } else if (
+      trimmed.includes("\u2717") ||
+      trimmed.includes("failed") ||
+      trimmed.includes("Error")
+    ) {
+      logger.error(trimmed);
+    } else if (
+      trimmed.includes("─") ||
+      trimmed.includes("Running") ||
+      trimmed.includes("test")
+    ) {
+      logger.dim(trimmed);
+    }
+  }
+}
+
+function extractFirstError(output) {
+  if (!output) return "Unknown error";
+  const lines = output.split("\n").filter((l) => l.trim());
+  const errorLine = lines.find(
+    (l) =>
+      l.includes("Error") ||
+      l.includes("expect") ||
+      l.includes("Timeout") ||
+      l.includes("locator"),
+  );
+  return (
+    errorLine?.trim().slice(0, 150) ||
+    lines[0]?.trim().slice(0, 150) ||
+    "Test failed"
+  );
+}
+
+function guessRoute(featureName) {
+  const routes = {
+    home: "/",
+    lobby: "/lobby",
+    auth: "/signin",
+    account: "/account",
+    redemption: "/redemption",
+    "refer-a-friend": "/refer-a-friend",
+    faq: "/faq",
+    promotions: "/promotions",
+    "game-details": "/game-details",
+    "game-zone": "/game-zone",
+    "privacy-policy": "/privacy-policy",
+    "terms-of-service": "/terms-of-service",
+  };
+  return routes[featureName] || `/${featureName}`;
+}
+
+async function generateE2EReport(projectDir, config, feature, env, baseUrl) {
+  try {
+    const screenshotsDir = path.join(projectDir, "e2e", "screenshots");
+    const screenshots = await findFiles(screenshotsDir, "*.png").catch(
+      () => [],
+    );
+
+    const reporter = new ReportGenerator(config);
+    const results = {
+      summary: {
+        totalTests: 0,
+        totalPassed: 0,
+        totalFailed: 0,
+        totalSkipped: 0,
+        overallPassRate: 0,
+        byLayer: {},
+      },
+      results: [],
+    };
+
+    const pwResultsPath = path.join(
+      projectDir,
+      "qabot-reports",
+      "playwright",
+      "results.json",
+    );
+    if (await fileExists(pwResultsPath)) {
+      try {
+        const pwResults = JSON.parse(await readFile(pwResultsPath, "utf-8"));
+        if (pwResults.suites) {
+          const tests = [];
+          flattenSuites(pwResults.suites, tests);
+          results.results = [
+            {
+              runner: "playwright",
+              layer: "e2e",
+              feature,
+              tests,
+              summary: {
+                total: tests.length,
+                passed: tests.filter((t) => t.status === "passed").length,
+                failed: tests.filter((t) => t.status === "failed").length,
+                skipped: tests.filter((t) => t.status === "skipped").length,
+              },
+            },
+          ];
+          results.summary.totalTests = tests.length;
+          results.summary.totalPassed = tests.filter(
+            (t) => t.status === "passed",
+          ).length;
+          results.summary.totalFailed = tests.filter(
+            (t) => t.status === "failed",
+          ).length;
+          results.summary.overallPassRate =
+            tests.length > 0
+              ? Math.round((results.summary.totalPassed / tests.length) * 100)
+              : 0;
+        }
+      } catch {
+        /* skip malformed results */
+      }
+    }
+
+    const reportPaths = await reporter.generate(results, {
+      feature,
+      environment: env,
+      projectName: config.project?.name || "unknown",
+      timestamp: new Date().toISOString(),
+      duration: 0,
+    });
+
+    logger.blank();
+    logger.info(`Report: ${chalk.underline(reportPaths.htmlPath)}`);
+  } catch {
+    /* report generation is best-effort */
+  }
+}
+
+function flattenSuites(suites, tests) {
+  for (const suite of suites || []) {
+    for (const spec of suite.specs || []) {
+      for (const test of spec.tests || []) {
+        const result = test.results?.[test.results.length - 1];
+        tests.push({
+          name: spec.title,
+          suite: suite.title,
+          file: suite.file || "",
+          status:
+            test.status === "expected"
+              ? "passed"
+              : test.status === "skipped"
+                ? "skipped"
+                : "failed",
+          duration: result?.duration || 0,
+          error: result?.error
+            ? {
+                message: result.error.message || "",
+                stack: result.error.stack || "",
+              }
+            : null,
+          screenshots: (result?.attachments || [])
+            .filter((a) => a.contentType?.startsWith("image/"))
+            .map((a) => a.path),
+        });
+      }
+    }
+    if (suite.suites) flattenSuites(suite.suites, tests);
+  }
+}

package/src/core/constants.js

@@ -1,4 +1,4 @@
-export const VERSION = "0.5.1";
+export const VERSION = "0.6.0";
 export const TOOL_NAME = "qabot";
 
 export const PROJECT_TYPES = [

package/src/e2e/e2e-generator.js

@@ -0,0 +1,61 @@
+import { buildE2EPrompt } from "./e2e-prompts.js";
+
+export async function generateE2ESpec(ai, featureName, context) {
+  const prompt = buildE2EPrompt(featureName, context);
+
+  const savedMaxTokens = ai.maxTokens;
+  ai.maxTokens = Math.max(ai.maxTokens, 8192);
+  try {
+    const code = await ai.complete(prompt);
+    return cleanSpec(code);
+  } finally {
+    ai.maxTokens = savedMaxTokens;
+  }
+}
+
+export async function fixE2ESpec(ai, code, errorMessage, context) {
+  const prompt = `You are fixing a broken Playwright E2E test.
+
+## Error
+\`\`\`
+${errorMessage.slice(0, 2000)}
+\`\`\`
+
+## Current test code
+\`\`\`javascript
+${code}
+\`\`\`
+
+## Context
+- Base URL: ${context.baseUrl || "http://localhost:3000"}
+- Auth: ${context.authProvider || "none"}
+
+## Common Playwright fixes
+1. Wrong selector — use getByRole, getByText, getByTestId instead of CSS selectors
+2. Timing — add waitForLoadState("networkidle") or waitForSelector
+3. Element not visible — scroll into view or wait for animation
+4. Navigation — ensure page.goto uses correct path
+5. Auth — ensure login completed before testing
+
+Return the COMPLETE fixed test file. No markdown fences.`;
+
+  const savedMaxTokens = ai.maxTokens;
+  ai.maxTokens = Math.max(ai.maxTokens, 8192);
+  try {
+    const fixed = await ai.complete(prompt);
+    return cleanSpec(fixed);
+  } finally {
+    ai.maxTokens = savedMaxTokens;
+  }
+}
+
+function cleanSpec(code) {
+  let cleaned = code.trim();
+  if (cleaned.startsWith("```")) {
+    cleaned = cleaned.slice(cleaned.indexOf("\n") + 1);
+  }
+  if (cleaned.endsWith("```")) {
+    cleaned = cleaned.slice(0, cleaned.lastIndexOf("```"));
+  }
+  return cleaned.trim() + "\n";
+}

package/src/e2e/e2e-prompts.js

@@ -0,0 +1,66 @@
+export function buildE2EPrompt(featureName, context) {
+  const sourceSection = context.sourceCode
+    ? `\n## Source Code (for understanding page structure)\n\`\`\`\n${context.sourceCode.slice(0, 6000)}\n\`\`\`\n`
+    : "";
+
+  const routeSection = context.route
+    ? `\n## Page Route: ${context.route}\n`
+    : "";
+
+  const useCaseSection = context.useCases?.length
+    ? `\n## QA Use Cases\n${context.useCases.map((uc) => `### ${uc.scenario}\n${uc.steps.map((s, i) => `${i + 1}. ${s}`).join("\n")}`).join("\n\n")}\n`
+    : "";
+
+  return `You are a senior QA automation engineer writing Playwright E2E tests.
+
+## Feature: ${featureName}
+## Base URL: ${context.baseUrl || "http://localhost:3000"}
+## Auth Provider: ${context.authProvider || "none"}
+${routeSection}${sourceSection}${useCaseSection}
+## Task
+Write a Playwright test spec for the "${featureName}" feature. The test should:
+1. Navigate to the correct page
+2. Verify the page loads correctly (key elements visible)
+3. Test main user interactions
+4. Take screenshots at key checkpoints
+5. Verify expected outcomes
+
+## Playwright Rules
+1. Use \`const { test, expect } = require("@playwright/test");\`
+2. Use \`test.describe\` for grouping, \`test\` for individual tests
+3. Use accessible selectors: \`page.getByRole()\`, \`page.getByText()\`, \`page.getByTestId()\`
+4. Use \`await page.waitForLoadState("networkidle")\` after navigation
+5. Use \`await page.screenshot({ path: "e2e/screenshots/${featureName}-{step}.png" })\` at key points
+6. Use \`expect(page).toHaveURL()\` for navigation verification
+7. Use \`expect(locator).toBeVisible()\` for element verification
+8. Handle authentication if needed:
+   \`\`\`
+   const { login } = require("../helpers/auth.js");
+   test.beforeEach(async ({ page, baseURL }) => { await login(page, baseURL); });
+   \`\`\`
+9. Each test should be independent
+10. Add reasonable timeouts for slow operations
+
+## Structure
+\`\`\`
+test.describe("${featureName}", () => {
+  test.beforeEach(async ({ page, baseURL }) => {
+    // login if needed
+    // navigate to feature page
+  });
+
+  test("page loads correctly", async ({ page }) => {
+    // verify key elements
+    // take screenshot
+  });
+
+  test("main interaction works", async ({ page }) => {
+    // perform action
+    // verify outcome
+    // take screenshot
+  });
+});
+\`\`\`
+
+Return ONLY the JavaScript code. No markdown fences. No explanation.`;
+}

package/src/e2e/playwright-setup.js

@@ -0,0 +1,144 @@
+import path from "node:path";
+import { execSync } from "node:child_process";
+import { writeFile } from "node:fs/promises";
+import { fileExists, ensureDir } from "../utils/file-utils.js";
+
+export async function ensurePlaywright(projectDir) {
+  const pwBin = path.join(projectDir, "node_modules", ".bin", "playwright");
+
+  if (!(await fileExists(pwBin))) {
+    execSync("npm install -D @playwright/test", {
+      cwd: projectDir,
+      stdio: "pipe",
+    });
+  }
+
+  try {
+    execSync("npx playwright install chromium", {
+      cwd: projectDir,
+      stdio: "pipe",
+      timeout: 120000,
+    });
+  } catch {
+    execSync("npx playwright install", {
+      cwd: projectDir,
+      stdio: "pipe",
+      timeout: 120000,
+    });
+  }
+
+  return true;
+}
+
+export async function ensureE2EStructure(projectDir) {
+  const dirs = [
+    "e2e/tests",
+    "e2e/pages",
+    "e2e/helpers",
+    "e2e/.auth",
+    "e2e/screenshots",
+  ];
+  for (const dir of dirs) {
+    await ensureDir(path.join(projectDir, dir));
+  }
+}
+
+export async function writePlaywrightConfig(projectDir, config) {
+  const configPath = path.join(projectDir, "e2e", "playwright.config.js");
+  if (await fileExists(configPath)) return configPath;
+
+  const envUrls = {};
+  if (config.environments) {
+    for (const [name, env] of Object.entries(config.environments)) {
+      if (env.url) envUrls[name] = env.url;
+    }
+  }
+
+  const content = `const { defineConfig, devices } = require("@playwright/test");
+
+const ENV_URLS = ${JSON.stringify(envUrls, null, 2)};
+
+module.exports = defineConfig({
+  testDir: "./tests",
+  fullyParallel: false,
+  retries: 1,
+  workers: 1,
+  reporter: [
+    ["html", { open: "never", outputFolder: "../qabot-reports/playwright" }],
+    ["json", { outputFile: "../qabot-reports/playwright/results.json" }],
+  ],
+  use: {
+    baseURL: ENV_URLS[process.env.E2E_ENV || "default"] || "http://localhost:3000",
+    trace: "on-first-retry",
+    screenshot: "on",
+    ignoreHTTPSErrors: true,
+    actionTimeout: 10000,
+    navigationTimeout: 30000,
+  },
+  projects: [
+    {
+      name: "chromium",
+      use: { ...devices["Desktop Chrome"] },
+    },
+  ],
+});
+`;
+
+  await writeFile(configPath, content, "utf-8");
+  return configPath;
+}
+
+export async function writeAuthHelper(projectDir, config) {
+  const helperPath = path.join(projectDir, "e2e", "helpers", "auth.js");
+  if (await fileExists(helperPath)) return;
+
+  const authProvider = config.auth?.provider || "none";
+  const content = `const { expect } = require("@playwright/test");
+
+async function login(page, baseURL) {
+  const email = process.env.E2E_TEST_EMAIL || "";
+  const password = process.env.E2E_TEST_PASSWORD || "";
+
+  if (!email || !password) {
+    console.warn("E2E_TEST_EMAIL or E2E_TEST_PASSWORD not set — skipping login");
+    return;
+  }
+
+  await page.goto(baseURL || "/");
+  await page.waitForLoadState("networkidle");
+
+  ${
+    authProvider === "auth0"
+      ? `
+  const signInBtn = page.getByRole("button", { name: /sign in/i })
+    .or(page.getByRole("link", { name: /sign in/i }))
+    .or(page.locator("[data-testid='sign-in-button']"));
+  
+  if (await signInBtn.isVisible({ timeout: 5000 }).catch(() => false)) {
+    await signInBtn.click();
+    await page.waitForLoadState("networkidle");
+  }
+
+  const emailInput = page.getByLabel(/email/i).or(page.locator("input[name='email']")).or(page.locator("input[type='email']"));
+  if (await emailInput.isVisible({ timeout: 5000 }).catch(() => false)) {
+    await emailInput.fill(email);
+    const passwordInput = page.getByLabel(/password/i).or(page.locator("input[name='password']")).or(page.locator("input[type='password']"));
+    await passwordInput.fill(password);
+    const submitBtn = page.getByRole("button", { name: /continue|log in|sign in|submit/i });
+    await submitBtn.click();
+    await page.waitForLoadState("networkidle");
+  }`
+      : `
+  // Generic login — customize for your auth provider
+  await page.getByLabel(/email/i).fill(email);
+  await page.getByLabel(/password/i).fill(password);
+  await page.getByRole("button", { name: /sign in|log in|submit/i }).click();
+  await page.waitForLoadState("networkidle");`
+  }
+}
+
+module.exports = { login };
+`;
+
+  await writeFile(helperPath, content, "utf-8");
+}