@nhonh/qabot 0.1.0

package/src/reporter/report-generator.js

@@ -0,0 +1,84 @@
+import path from "node:path";
+import { writeFile, readdir, readFile } from "node:fs/promises";
+import { ensureDir, writeJSON } from "../utils/file-utils.js";
+import { HtmlBuilder } from "./html-builder.js";
+import { openInBrowser } from "./report-server.js";
+
+export class ReportGenerator {
+  constructor(config) {
+    this.config = config;
+    this.outputDir = config.reporting?.outputDir || "./qabot-reports";
+  }
+
+  async generate(results, meta) {
+    const dateStr = new Date().toISOString().slice(0, 10);
+    const reportDir = path.join(
+      this.outputDir,
+      `${dateStr}_${meta.feature || "all"}`,
+    );
+    await ensureDir(reportDir);
+
+    const jsonPath = path.join(reportDir, "results.json");
+    await writeJSON(jsonPath, results);
+
+    const htmlBuilder = new HtmlBuilder();
+    const html = htmlBuilder.render(results, meta);
+    const htmlPath = path.join(reportDir, "index.html");
+    await writeFile(htmlPath, html, "utf-8");
+
+    if (this.config.reporting?.openAfterRun) {
+      try {
+        await openInBrowser(path.resolve(htmlPath));
+      } catch {
+        /* noop */
+      }
+    }
+
+    return {
+      reportDir,
+      htmlPath: path.resolve(htmlPath),
+      jsonPath: path.resolve(jsonPath),
+    };
+  }
+
+  async openLatest() {
+    const reports = await this.listReports();
+    if (reports.length === 0) throw new Error("No reports found");
+    await openInBrowser(reports[0].htmlPath);
+  }
+
+  async listReports() {
+    try {
+      const entries = await readdir(this.outputDir, { withFileTypes: true });
+      const dirs = entries
+        .filter((e) => e.isDirectory())
+        .map((e) => e.name)
+        .sort()
+        .reverse();
+
+      const reports = [];
+      for (const dir of dirs) {
+        const jsonPath = path.join(this.outputDir, dir, "results.json");
+        const htmlPath = path.resolve(
+          path.join(this.outputDir, dir, "index.html"),
+        );
+        try {
+          const data = JSON.parse(await readFile(jsonPath, "utf-8"));
+          const parts = dir.split("_");
+          reports.push({
+            date: parts[0] || dir,
+            feature: parts.slice(1).join("_") || "all",
+            passRate: data.summary?.overallPassRate || 0,
+            path: htmlPath,
+            htmlPath,
+          });
+        } catch {
+          /* skip broken reports */
+        }
+      }
+      return reports;
+    } catch {
+      return [];
+    }
+  }
+}

package/src/reporter/report-server.js

@@ -0,0 +1,18 @@
+import { exec } from "node:child_process";
+import { platform } from "node:os";
+
+export async function openInBrowser(filePath) {
+  const commands = {
+    darwin: `open "${filePath}"`,
+    win32: `start "" "${filePath}"`,
+    linux: `xdg-open "${filePath}"`,
+  };
+  const cmd = commands[platform()] || commands.linux;
+
+  return new Promise((resolve, reject) => {
+    exec(cmd, (err) => {
+      if (err) reject(err);
+      else resolve();
+    });
+  });
+}

package/src/runners/base-runner.js

@@ -0,0 +1,19 @@
+export class BaseRunner {
+  constructor(name, config = {}) {
+    this.name = name;
+    this.config = config;
+  }
+
+  async isAvailable(projectDir) {
+    throw new Error(`${this.name}: isAvailable not implemented`);
+  }
+  buildCommand(options) {
+    throw new Error(`${this.name}: buildCommand not implemented`);
+  }
+  parseOutput(stdout, stderr, exitCode) {
+    throw new Error(`${this.name}: parseOutput not implemented`);
+  }
+  getDisplayName() {
+    return this.name.charAt(0).toUpperCase() + this.name.slice(1);
+  }
+}

package/src/runners/dotnet-runner.js

@@ -0,0 +1,54 @@
+import { BaseRunner } from "./base-runner.js";
+import { fileExists } from "../utils/file-utils.js";
+
+export class DotnetRunner extends BaseRunner {
+  constructor(config) {
+    super("dotnet-test", config);
+  }
+  getDisplayName() {
+    return ".NET Test";
+  }
+
+  async isAvailable() {
+    try {
+      const { execSync } = await import("node:child_process");
+      execSync("dotnet --version", { stdio: "pipe" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  buildCommand(options = {}) {
+    if (this.config.command && options.pattern) {
+      return this.config.command.replace("{pattern}", options.pattern);
+    }
+    const parts = ["dotnet", "test"];
+    if (options.pattern) parts.push(`--filter "${options.pattern}"`);
+    parts.push('--logger "trx"', "--results-directory ./qabot-test-results");
+    if (options.verbose) parts.push("--verbosity normal");
+    return parts.join(" ");
+  }
+
+  parseOutput(stdout, stderr, exitCode) {
+    const tests = [];
+    const passMatch = stdout.match(/Passed:\s+(\d+)/);
+    const failMatch = stdout.match(/Failed:\s+(\d+)/);
+    const skipMatch = stdout.match(/Skipped:\s+(\d+)/);
+    const totalMatch = stdout.match(/Total:\s+(\d+)/);
+
+    const summary = {
+      total: parseInt(totalMatch?.[1] || "0"),
+      passed: parseInt(passMatch?.[1] || "0"),
+      failed: parseInt(failMatch?.[1] || "0"),
+      skipped: parseInt(skipMatch?.[1] || "0"),
+      passRate: 0,
+    };
+    summary.passRate =
+      summary.total > 0
+        ? Math.round((summary.passed / summary.total) * 100)
+        : 0;
+
+    return { tests, summary, coverage: null };
+  }
+}

package/src/runners/jest-runner.js

@@ -0,0 +1,118 @@
+import path from "node:path";
+import { tmpdir } from "node:os";
+import { nanoid } from "nanoid";
+import { BaseRunner } from "./base-runner.js";
+import { fileExists, readJSON } from "../utils/file-utils.js";
+
+export class JestRunner extends BaseRunner {
+  constructor(config) {
+    super("jest", config);
+  }
+  getDisplayName() {
+    return "Jest";
+  }
+
+  async isAvailable(projectDir) {
+    return fileExists(path.join(projectDir, "node_modules", ".bin", "jest"));
+  }
+
+  buildCommand(options = {}) {
+    if (this.config.command && options.pattern) {
+      return this.config.command.replace("{pattern}", options.pattern);
+    }
+
+    const parts = ["npx", "jest"];
+    if (options.pattern) parts.push(`--testPathPattern="${options.pattern}"`);
+    if (options.coverage) parts.push("--coverage");
+
+    const jsonFile = path.join(tmpdir(), `qabot-jest-${nanoid(8)}.json`);
+    parts.push("--json", `--outputFile="${jsonFile}"`);
+    parts.push("--forceExit", "--detectOpenHandles");
+    this._jsonFile = jsonFile;
+    return parts.join(" ");
+  }
+
+  parseOutput(stdout, stderr, exitCode) {
+    const tests = [];
+    let jsonData = null;
+
+    try {
+      if (this._jsonFile) {
+        jsonData = JSON.parse(
+          require("node:fs").readFileSync(this._jsonFile, "utf-8"),
+        );
+      }
+    } catch {
+      /* fallback to stdout parsing */
+    }
+
+    if (!jsonData) {
+      try {
+        const jsonStart = stdout.indexOf("{");
+        if (jsonStart !== -1) jsonData = JSON.parse(stdout.slice(jsonStart));
+      } catch {
+        /* parse manually */
+      }
+    }
+
+    if (jsonData && jsonData.testResults) {
+      for (const suite of jsonData.testResults) {
+        for (const test of suite.assertionResults || []) {
+          tests.push({
+            name: test.fullName || test.title,
+            suite: test.ancestorTitles?.join(" > ") || "",
+            file: path.relative(process.cwd(), suite.testFilePath || ""),
+            status: mapJestStatus(test.status),
+            duration: test.duration || 0,
+            error: test.failureMessages?.length
+              ? { message: test.failureMessages.join("\n"), stack: "" }
+              : null,
+            screenshots: [],
+            retries: 0,
+          });
+        }
+      }
+    }
+
+    const summary = jsonData
+      ? {
+          total: jsonData.numTotalTests || 0,
+          passed: jsonData.numPassedTests || 0,
+          failed: jsonData.numFailedTests || 0,
+          skipped:
+            (jsonData.numPendingTests || 0) + (jsonData.numTodoTests || 0),
+        }
+      : parseSummaryFromStdout(stdout);
+
+    summary.passRate =
+      summary.total > 0
+        ? Math.round((summary.passed / summary.total) * 100)
+        : 0;
+
+    return { tests, summary, coverage: jsonData?.coverageMap || null };
+  }
+}
+
+function mapJestStatus(status) {
+  const map = {
+    passed: "passed",
+    failed: "failed",
+    pending: "skipped",
+    todo: "skipped",
+  };
+  return map[status] || "skipped";
+}
+
+function parseSummaryFromStdout(stdout) {
+  const summary = { total: 0, passed: 0, failed: 0, skipped: 0, passRate: 0 };
+  const testMatch = stdout.match(
+    /Tests:\s+(?:(\d+) failed,\s+)?(?:(\d+) skipped,\s+)?(?:(\d+) passed,\s+)?(\d+) total/,
+  );
+  if (testMatch) {
+    summary.failed = parseInt(testMatch[1] || "0");
+    summary.skipped = parseInt(testMatch[2] || "0");
+    summary.passed = parseInt(testMatch[3] || "0");
+    summary.total = parseInt(testMatch[4] || "0");
+  }
+  return summary;
+}

package/src/runners/playwright-runner.js

@@ -0,0 +1,106 @@
+import path from "node:path";
+import { BaseRunner } from "./base-runner.js";
+import { fileExists } from "../utils/file-utils.js";
+
+export class PlaywrightRunner extends BaseRunner {
+  constructor(config) {
+    super("playwright", config);
+  }
+  getDisplayName() {
+    return "Playwright";
+  }
+
+  async isAvailable(projectDir) {
+    return fileExists(
+      path.join(projectDir, "node_modules", ".bin", "playwright"),
+    );
+  }
+
+  buildCommand(options = {}) {
+    if (this.config.command && options.pattern) {
+      return this.config.command.replace("{pattern}", options.pattern);
+    }
+
+    const parts = ["npx", "playwright", "test"];
+    if (options.pattern) parts.push(options.pattern);
+    if (options.project) parts.push(`--project=${options.project}`);
+    if (options.headed) parts.push("--headed");
+    if (options.grep) parts.push(`--grep="${options.grep}"`);
+    parts.push("--reporter=json");
+    return parts.join(" ");
+  }
+
+  parseOutput(stdout, stderr, exitCode) {
+    const tests = [];
+    let jsonData = null;
+
+    try {
+      const jsonStart = stdout.indexOf("{");
+      if (jsonStart !== -1) jsonData = JSON.parse(stdout.slice(jsonStart));
+    } catch {
+      /* fall through to manual parse */
+    }
+
+    if (jsonData?.suites) {
+      flattenPlaywrightSuites(jsonData.suites, tests);
+    }
+
+    const 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,
+      passRate: 0,
+    };
+    summary.passRate =
+      summary.total > 0
+        ? Math.round((summary.passed / summary.total) * 100)
+        : 0;
+
+    return { tests, summary, coverage: null };
+  }
+}
+
+function flattenPlaywrightSuites(suites, tests, parentTitle = "") {
+  for (const suite of suites) {
+    const suiteName = parentTitle
+      ? `${parentTitle} > ${suite.title}`
+      : suite.title;
+
+    for (const spec of suite.specs || []) {
+      for (const test of spec.tests || []) {
+        const lastResult = test.results?.[test.results.length - 1];
+        tests.push({
+          name: spec.title,
+          suite: suiteName,
+          file: suite.file || "",
+          status: mapPlaywrightStatus(test.status || lastResult?.status),
+          duration: lastResult?.duration || 0,
+          error: lastResult?.error
+            ? {
+                message: lastResult.error.message || "",
+                stack: lastResult.error.stack || "",
+              }
+            : null,
+          screenshots: (lastResult?.attachments || [])
+            .filter((a) => a.contentType?.startsWith("image/"))
+            .map((a) => a.path),
+          retries: (test.results?.length || 1) - 1,
+        });
+      }
+    }
+
+    if (suite.suites) flattenPlaywrightSuites(suite.suites, tests, suiteName);
+  }
+}
+
+function mapPlaywrightStatus(status) {
+  const map = {
+    expected: "passed",
+    unexpected: "failed",
+    flaky: "passed",
+    skipped: "skipped",
+    timedOut: "failed",
+  };
+  return map[status] || status || "skipped";
+}

package/src/runners/pytest-runner.js

@@ -0,0 +1,84 @@
+import { BaseRunner } from "./base-runner.js";
+
+export class PytestRunner extends BaseRunner {
+  constructor(config) {
+    super("pytest", config);
+  }
+  getDisplayName() {
+    return "pytest";
+  }
+
+  async isAvailable() {
+    try {
+      const { execSync } = await import("node:child_process");
+      execSync("python3 -m pytest --version", { stdio: "pipe" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  buildCommand(options = {}) {
+    if (this.config.command && options.pattern) {
+      return this.config.command.replace("{pattern}", options.pattern);
+    }
+    const parts = ["python3", "-m", "pytest"];
+    if (options.pattern) parts.push(options.pattern);
+    parts.push("--tb=short", "-q");
+    if (options.verbose) parts.push("-v");
+    return parts.join(" ");
+  }
+
+  parseOutput(stdout, stderr, exitCode) {
+    const tests = [];
+    const lines = stdout.split("\n");
+
+    for (const line of lines) {
+      const passedMatch = line.match(/^(.+?)\s+PASSED/);
+      const failedMatch = line.match(/^(.+?)\s+FAILED/);
+      if (passedMatch)
+        tests.push({
+          name: passedMatch[1].trim(),
+          suite: "",
+          file: "",
+          status: "passed",
+          duration: 0,
+          error: null,
+          screenshots: [],
+          retries: 0,
+        });
+      if (failedMatch)
+        tests.push({
+          name: failedMatch[1].trim(),
+          suite: "",
+          file: "",
+          status: "failed",
+          duration: 0,
+          error: { message: "Test failed", stack: "" },
+          screenshots: [],
+          retries: 0,
+        });
+    }
+
+    const summaryMatch = stdout.match(
+      /(\d+) passed(?:,\s*(\d+) failed)?(?:,\s*(\d+) skipped)?/,
+    );
+    const summary = {
+      total:
+        tests.length ||
+        parseInt(summaryMatch?.[1] || "0") +
+          parseInt(summaryMatch?.[2] || "0") +
+          parseInt(summaryMatch?.[3] || "0"),
+      passed: parseInt(summaryMatch?.[1] || "0"),
+      failed: parseInt(summaryMatch?.[2] || "0"),
+      skipped: parseInt(summaryMatch?.[3] || "0"),
+      passRate: 0,
+    };
+    summary.passRate =
+      summary.total > 0
+        ? Math.round((summary.passed / summary.total) * 100)
+        : 0;
+
+    return { tests, summary, coverage: null };
+  }
+}

package/src/runners/runner-registry.js

@@ -0,0 +1,32 @@
+import { JestRunner } from "./jest-runner.js";
+import { VitestRunner } from "./vitest-runner.js";
+import { PlaywrightRunner } from "./playwright-runner.js";
+import { DotnetRunner } from "./dotnet-runner.js";
+import { PytestRunner } from "./pytest-runner.js";
+
+const RUNNERS = {
+  jest: JestRunner,
+  vitest: VitestRunner,
+  playwright: PlaywrightRunner,
+  cypress: PlaywrightRunner,
+  "dotnet-test": DotnetRunner,
+  dotnet: DotnetRunner,
+  pytest: PytestRunner,
+};
+
+export function getRunner(name, config = {}) {
+  const RunnerClass = RUNNERS[name];
+  if (!RunnerClass)
+    throw new Error(
+      `Unknown runner: ${name}. Available: ${Object.keys(RUNNERS).join(", ")}`,
+    );
+  return new RunnerClass(config);
+}
+
+export function listRunners() {
+  return Object.keys(RUNNERS);
+}
+
+export function isKnownRunner(name) {
+  return name in RUNNERS;
+}

package/src/runners/vitest-runner.js

@@ -0,0 +1,74 @@
+import path from "node:path";
+import { BaseRunner } from "./base-runner.js";
+import { fileExists } from "../utils/file-utils.js";
+
+export class VitestRunner extends BaseRunner {
+  constructor(config) {
+    super("vitest", config);
+  }
+  getDisplayName() {
+    return "Vitest";
+  }
+
+  async isAvailable(projectDir) {
+    return fileExists(path.join(projectDir, "node_modules", ".bin", "vitest"));
+  }
+
+  buildCommand(options = {}) {
+    if (this.config.command && options.pattern) {
+      return this.config.command.replace("{pattern}", options.pattern);
+    }
+    const parts = ["npx", "vitest", "run", "--reporter=json"];
+    if (options.pattern) parts.push(options.pattern);
+    if (options.coverage) parts.push("--coverage");
+    return parts.join(" ");
+  }
+
+  parseOutput(stdout, stderr, exitCode) {
+    const tests = [];
+    let jsonData = null;
+    try {
+      const jsonStart = stdout.indexOf("{");
+      if (jsonStart !== -1) jsonData = JSON.parse(stdout.slice(jsonStart));
+    } catch {
+      /* noop */
+    }
+
+    if (jsonData?.testResults) {
+      for (const suite of jsonData.testResults) {
+        for (const test of suite.assertionResults || []) {
+          tests.push({
+            name: test.fullName || test.title,
+            suite: test.ancestorTitles?.join(" > ") || "",
+            file: suite.name || "",
+            status:
+              test.status === "passed"
+                ? "passed"
+                : test.status === "failed"
+                  ? "failed"
+                  : "skipped",
+            duration: test.duration || 0,
+            error: test.failureMessages?.length
+              ? { message: test.failureMessages.join("\n"), stack: "" }
+              : null,
+            screenshots: [],
+            retries: 0,
+          });
+        }
+      }
+    }
+
+    const 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,
+      passRate: 0,
+    };
+    summary.passRate =
+      summary.total > 0
+        ? Math.round((summary.passed / summary.total) * 100)
+        : 0;
+    return { tests, summary, coverage: null };
+  }
+}

package/src/utils/file-utils.js

@@ -0,0 +1,69 @@
+import {
+  readFile,
+  writeFile as fsWriteFile,
+  mkdir,
+  readdir,
+  stat,
+  access,
+} from "node:fs/promises";
+import { constants } from "node:fs";
+import path from "node:path";
+import { glob } from "glob";
+
+export async function fileExists(filePath) {
+  try {
+    await access(filePath, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function ensureDir(dirPath) {
+  await mkdir(dirPath, { recursive: true });
+}
+
+export async function readJSON(filePath) {
+  const content = await readFile(filePath, "utf-8");
+  return JSON.parse(content);
+}
+
+export async function writeJSON(filePath, data) {
+  await ensureDir(path.dirname(filePath));
+  await fsWriteFile(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+
+export async function findFiles(dir, pattern) {
+  return glob(pattern, { cwd: dir, absolute: true, nodir: true });
+}
+
+export async function getProjectRoot(startDir) {
+  let current = startDir || process.cwd();
+  while (current !== path.dirname(current)) {
+    if (
+      (await fileExists(path.join(current, "package.json"))) ||
+      (await fileExists(path.join(current, ".git")))
+    ) {
+      return current;
+    }
+    current = path.dirname(current);
+  }
+  return startDir || process.cwd();
+}
+
+export async function safeReadFile(filePath) {
+  try {
+    return await readFile(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+export async function listDirs(dirPath) {
+  try {
+    const entries = await readdir(dirPath, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}