@nhonh/qabot 0.5.1 → 0.6.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Hoài Nhớ
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,406 @@
+<p align="center">
+  <img src="https://img.shields.io/badge/QABot-AI%20Powered%20QA-7c3aed?style=for-the-badge&logo=data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0id2hpdGUiPjxwYXRoIGQ9Ik05LjQgMTYuNkw0LjggMTJsNC42LTQuNkw4IDZsLTYgNiA2IDYgMS40LTEuNHptNS4yIDBsNC42LTQuNi00LjYtNC42TDE2IDZsNiA2LTYgNi0xLjQtMS40eiIvPjwvc3ZnPg==&logoColor=white" alt="QABot" />
+</p>
+
+<h1 align="center">QABot</h1>
+
+<p align="center">
+  <strong>AI-Powered Universal QA Automation Tool</strong>
+</p>
+
+<p align="center">
+  Import any project. AI analyzes structure. Run tests across all layers. Zero config.
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/@nhonh/qabot"><img src="https://img.shields.io/npm/v/@nhonh/qabot?color=cb3837&logo=npm" alt="npm version" /></a>
+  <a href="https://www.npmjs.com/package/@nhonh/qabot"><img src="https://img.shields.io/npm/dw/@nhonh/qabot?color=cb3837&logo=npm&label=downloads%2Fweek" alt="npm downloads/week" /></a>
+  <a href="https://www.npmjs.com/package/@nhonh/qabot"><img src="https://img.shields.io/npm/dt/@nhonh/qabot?color=cb3837&logo=npm&label=total%20downloads" alt="total downloads" /></a>
+  <a href="https://github.com/hoainho/qabot/blob/main/LICENSE"><img src="https://img.shields.io/npm/l/@nhonh/qabot?color=blue" alt="license" /></a>
+  <a href="https://nodejs.org"><img src="https://img.shields.io/node/v/@nhonh/qabot?color=339933&logo=node.js&logoColor=white" alt="node version" /></a>
+  <a href="https://github.com/hoainho/qabot"><img src="https://img.shields.io/github/stars/hoainho/qabot?style=social" alt="GitHub stars" /></a>
+</p>
+
+---
+
+## Why QABot?
+
+Testing is the most critical part of software development, but setting up and maintaining test infrastructure across frameworks, layers, and environments is painfully repetitive. **QABot eliminates that friction.**
+
+Point QABot at **any** project — React, Next.js, Vue, Angular, .NET, Python, or Node.js — and it will **auto-detect** your framework, test runners, features, and environments. Then it runs tests across **unit, integration, and E2E layers** from a single CLI. Need test cases? QABot's AI engine analyzes your code and **generates production-ready tests** using OpenAI, Claude, Gemini, or 4 other providers.
+
+---
+
+## Features
+
+- **AI-Powered Test Analysis** — AI analyzes your source code and generates comprehensive test cases. Supports OpenAI, Anthropic Claude, Google Gemini, DeepSeek, Groq, Ollama (local), and custom proxy endpoints.
+
+- **Smart Project Detection** — Auto-detects project type (React, Next.js, Vue, Angular, .NET, Python, Node.js), framework, bundler, state management, and auth provider. Zero configuration needed.
+
+- **Universal Test Runner** — Runs Jest, Vitest, Playwright, Cypress, pytest, xUnit, and dotnet-test from a single CLI. No more switching between different test commands.
+
+- **Beautiful HTML Reports** — Generates interactive HTML + JSON reports with pass/fail/skip statistics, duration tracking, and historical run comparison.
+
+- **E2E Test Generation** — AI generates Playwright E2E tests from feature descriptions with automatic error detection and self-healing fix capabilities.
+
+- **Multi-Layer Testing** — Run unit, integration, and E2E tests separately or together. Filter by layer with `--layer unit` or run everything at once.
+
+- **Environment Management** — Detect and switch between local, staging, and production environments. Each environment gets its own config and credentials.
+
+- **Use Case Driven** — Import use cases from Markdown, Gherkin Feature files, or plain text docs. Map them directly to test coverage.
+
+- **Extensible Runner System** — Plugin-based architecture makes it easy to add support for new test frameworks. Each runner extends a common `BaseRunner` interface.
+
+- **Multi-AI Provider** — Switch AI providers instantly. Configure during `qabot init` or change anytime in `qabot.config.json`. Supports 7 providers including local Ollama.
+
+---
+
+## Quick Start
+
+### Install
+
+```bash
+# Install globally
+npm install -g @nhonh/qabot
+
+# Or use npx (no install needed)
+npx @nhonh/qabot --help
+```
+
+### Initialize
+
+```bash
+cd your-project
+qabot init
+```
+
+QABot scans your project and generates a `qabot.config.json`:
+
+```
+  ╔═══════════════════════════════════╗
+  ║  QABot - Project Analysis         ║
+  ╠═══════════════════════════════════╣
+  ║  Project:    my-react-app         ║
+  ║  Type:       react-spa            ║
+  ║  Framework:  React 18             ║
+  ║  Runners:    Jest, Playwright     ║
+  ║  Features:   12 detected          ║
+  ║  Unit Tests: 45 files             ║
+  ║  E2E Tests:  8 files              ║
+  ╚═══════════════════════════════════╝
+```
+
+### Run Tests
+
+```bash
+# Run all tests
+qabot run
+
+# Run tests for a specific feature
+qabot run auth
+
+# Run only unit tests
+qabot run --layer unit
+
+# Run E2E tests against staging
+qabot run --layer e2e --env staging
+
+# Run with coverage
+qabot run --coverage
+
+# Verbose output
+qabot run --verbose
+```
+
+### Generate Tests with AI
+
+```bash
+# Generate test cases for a feature
+qabot generate login
+
+# Generate E2E tests
+qabot generate checkout --layer e2e
+```
+
+---
+
+## CLI Commands
+
+| Command | Description |
+|---|---|
+| `qabot init` | Analyze project and generate configuration |
+| `qabot init -y` | Initialize with all defaults (no prompts) |
+| `qabot run [feature]` | Run tests for all or a specific feature |
+| `qabot run --layer <layers>` | Run specific test layers (unit, integration, e2e) |
+| `qabot test` | Run tests with advanced options |
+| `qabot list` | Show detected features, test frameworks, and coverage |
+| `qabot generate <feature>` | AI-generate test cases for a feature |
+| `qabot report` | Open the latest HTML test report |
+| `qabot auth` | Configure authentication for E2E tests |
+
+---
+
+## Supported Frameworks
+
+| Category | Supported |
+|---|---|
+| **Frontend** | React, Next.js, Vue, Angular |
+| **Backend** | Node.js, .NET, Python |
+| **Test Runners** | Jest, Vitest, Playwright, Cypress, pytest, xUnit, dotnet-test |
+| **AI Providers** | OpenAI, Anthropic Claude, Google Gemini, DeepSeek, Groq, Ollama, Custom Proxy |
+| **Languages** | JavaScript, TypeScript, Python, C# |
+| **Package Managers** | npm, yarn, pnpm, pip, dotnet |
+
+---
+
+## Multi-Layer Testing
+
+QABot organizes tests into three distinct layers, each serving a specific purpose:
+
+### Unit Tests
+Validate individual functions, components, and modules in isolation. Fast feedback loop, run in milliseconds.
+
+```bash
+qabot run --layer unit
+```
+
+### Integration Tests
+Test how modules interact with each other, including API calls, database queries, and service communication.
+
+```bash
+qabot run --layer integration
+```
+
+### E2E Tests
+Full user journey simulation in a real browser. Tests the complete application stack from the user's perspective.
+
+```bash
+qabot run --layer e2e --env staging
+```
+
+### Test Priority System
+
+QABot assigns priorities to help you focus on what matters most:
+
+| Priority | Meaning | Example |
+|---|---|---|
+| **P0** | Critical — Must pass before deploy | Login, Payment, Core API |
+| **P1** | High — Important user journeys | Registration, Search, Profile |
+| **P2** | Medium — Standard features | Settings, Notifications |
+| **P3** | Low — Edge cases and cosmetic | Tooltips, Animations |
+
+---
+
+## AI Test Generation
+
+QABot's AI engine doesn't just suggest test names — it generates **complete, runnable test code**.
+
+### How It Works
+
+1. **Analyze** — AI reads your source code and understands component behavior, API contracts, and edge cases
+2. **Generate** — Produces full test files compatible with your test runner (Jest, Vitest, Playwright, etc.)
+3. **Auto-Fix** — If generated tests fail on first run, AI reads the error output and automatically fixes the code
+4. **Batch Support** — Handles large codebases by batching test generation (up to 8 test cases per batch)
+
+### Supported AI Providers
+
+| Provider | Model | Setup |
+|---|---|---|
+| **OpenAI** | GPT-4o | `OPENAI_API_KEY` |
+| **Anthropic** | Claude Sonnet 4 | `ANTHROPIC_API_KEY` |
+| **Google** | Gemini 2.5 Flash | `GEMINI_API_KEY` |
+| **DeepSeek** | DeepSeek Chat | `DEEPSEEK_API_KEY` |
+| **Groq** | Llama 3.3 70B | `GROQ_API_KEY` |
+| **Ollama** | Llama 3 (local) | No key needed |
+| **Custom Proxy** | Any model | `PROXY_API_KEY` + `baseUrl` |
+
+Configure during initialization:
+
+```bash
+qabot init
+# Select your AI provider when prompted
+```
+
+Or set in `qabot.config.json`:
+
+```json
+{
+  "ai": {
+    "provider": "anthropic",
+    "model": "claude-sonnet-4-20250514",
+    "apiKeyEnv": "ANTHROPIC_API_KEY"
+  }
+}
+```
+
+---
+
+## Configuration
+
+QABot uses a `qabot.config.json` file in your project root. Generated automatically by `qabot init`.
+
+```json
+{
+  "project": {
+    "name": "my-app",
+    "type": "react-spa"
+  },
+  "environments": {
+    "local": { "url": "http://localhost:3000" },
+    "staging": { "url": "https://staging.myapp.com" }
+  },
+  "layers": {
+    "unit": {
+      "runner": "jest",
+      "command": "npx jest {pattern}",
+      "testMatch": "**/*.test.*"
+    },
+    "e2e": {
+      "runner": "playwright",
+      "command": "npx playwright test {pattern}",
+      "testDir": "e2e/tests"
+    }
+  },
+  "features": {
+    "auth": { "src": "src/features/auth", "priority": "P0" },
+    "dashboard": { "src": "src/pages/Dashboard", "priority": "P1" },
+    "settings": { "src": "src/pages/Settings", "priority": "P2" }
+  },
+  "reporting": {
+    "outputDir": "./qabot-reports",
+    "openAfterRun": true,
+    "history": true,
+    "formats": ["html", "json"]
+  },
+  "ai": {
+    "provider": "openai",
+    "model": "gpt-4o",
+    "apiKeyEnv": "OPENAI_API_KEY"
+  },
+  "useCases": {
+    "dir": "./docs/use-cases",
+    "formats": ["md", "feature", "txt"]
+  }
+}
+```
+
+---
+
+## Reports
+
+QABot generates beautiful interactive reports after each test run:
+
+- **HTML Report** — Visual dashboard with pass/fail charts, duration breakdown, and test details
+- **JSON Report** — Machine-readable results for CI/CD integration
+- **Historical Tracking** — Compare results across runs to spot regressions
+- **Auto-Open** — Reports open in your browser automatically (configurable)
+
+View reports anytime:
+
+```bash
+qabot report
+```
+
+Reports are saved to `./qabot-reports/` organized by date and feature.
+
+---
+
+## Environment Variables
+
+Create a `.env` file in your project root (see `.env.example`):
+
+```env
+# AI Providers (set the one you use)
+OPENAI_API_KEY=sk-your-key-here
+ANTHROPIC_API_KEY=sk-ant-your-key-here
+GEMINI_API_KEY=your-gemini-key-here
+DEEPSEEK_API_KEY=your-deepseek-key-here
+GROQ_API_KEY=gsk_your-groq-key-here
+PROXY_API_KEY=your-proxy-key-here
+
+# E2E Test Credentials
+E2E_TEST_EMAIL=testuser@example.com
+E2E_TEST_PASSWORD=your-test-password
+```
+
+---
+
+## Architecture
+
+```
+qabot/
+├── bin/
+│   └── qabot.js              # CLI entry point
+├── src/
+│   ├── ai/                   # AI engine & prompt builders
+│   │   ├── ai-engine.js      # Multi-provider AI client
+│   │   ├── prompt-builder.js  # Test analysis/generation prompts
+│   │   └── usecase-parser.js  # Use case file parser
+│   ├── analyzers/             # Project analysis
+│   │   ├── project-analyzer.js
+│   │   ├── test-detector.js
+│   │   ├── feature-detector.js
+│   │   └── env-detector.js
+│   ├── cli/commands/          # CLI command handlers
+│   ├── core/                  # Config, constants, logger
+│   ├── e2e/                   # E2E test generation
+│   ├── executor/              # Test execution engine
+│   ├── reporter/              # HTML/JSON report generation
+│   ├── runners/               # Test framework runners
+│   │   ├── base-runner.js     # Runner interface
+│   │   ├── jest-runner.js
+│   │   ├── vitest-runner.js
+│   │   ├── playwright-runner.js
+│   │   ├── pytest-runner.js
+│   │   └── dotnet-runner.js
+│   └── utils/
+├── templates/                 # Config templates
+└── tests/                     # QABot's own test suite
+```
+
+---
+
+## Contributing
+
+Contributions are welcome! Here's how to get started:
+
+1. Fork the repository
+2. Create a feature branch: `git checkout -b feature/my-feature`
+3. Make your changes
+4. Run the test suite: `npm test`
+5. Commit your changes: `git commit -m "feat: add my feature"`
+6. Push to the branch: `git push origin feature/my-feature`
+7. Open a Pull Request
+
+### Development
+
+```bash
+git clone https://github.com/hoainho/qabot.git
+cd qabot
+npm install
+npm test
+npm run dev
+```
+
+---
+
+## Roadmap
+
+- [ ] GitHub Actions integration (auto-run on PR)
+- [ ] Slack/Discord notifications for test results
+- [ ] Visual regression testing support
+- [ ] Test coverage mapping and gap analysis
+- [ ] Custom reporter plugins
+- [ ] CI/CD pipeline templates
+
+---
+
+## License
+
+[MIT](./LICENSE) - Copyright (c) 2025 Hoai Nho
+
+---
+
+<p align="center">
+  Made with ❤️ by <a href="https://github.com/hoainho">Hoai Nho</a>
+</p>

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.1",
   "description": "AI-powered universal QA automation tool. Import any project, AI analyzes and runs tests across all layers.",
   "main": "src/index.js",
   "bin": {
@@ -28,8 +28,16 @@
     "test-report",
     "cli"
   ],
-  "author": "GearGames",
+  "author": "Hoài Nhớ <nhoxtvt@gmail.com> (https://github.com/hoainho)",
   "license": "MIT",
+  "homepage": "https://hoainho.github.io/qabot",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hoainho/qabot.git"
+  },
+  "bugs": {
+    "url": "https://github.com/hoainho/qabot/issues"
+  },
   "engines": {
     "node": ">=18.0.0"
   },

package/src/cli/commands/test.js

@@ -0,0 +1,467 @@
+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("-u, --url <url>", "Target URL (overrides environment config)")
+    .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 = options.url || 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.1";
 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");
+}