@nhonh/qabot 0.1.0

package/src/core/constants.js

@@ -0,0 +1,70 @@
+export const VERSION = "0.1.0";
+export const TOOL_NAME = "qabot";
+
+export const PROJECT_TYPES = [
+  "react-spa",
+  "nextjs",
+  "vue",
+  "angular",
+  "dotnet",
+  "python",
+  "node",
+  "unknown",
+];
+export const RUNNERS = [
+  "jest",
+  "vitest",
+  "playwright",
+  "cypress",
+  "pytest",
+  "xunit",
+  "dotnet-test",
+];
+export const AI_PROVIDERS = ["openai", "anthropic", "ollama", "none"];
+export const LAYERS = ["unit", "integration", "e2e"];
+export const PRIORITIES = ["P0", "P1", "P2", "P3"];
+
+export const TEST_STATUS = {
+  PASSED: "passed",
+  FAILED: "failed",
+  SKIPPED: "skipped",
+  PENDING: "pending",
+  RUNNING: "running",
+};
+
+export const DEFAULT_CONFIG = {
+  reporting: {
+    outputDir: "./qabot-reports",
+    openAfterRun: true,
+    history: true,
+    formats: ["html", "json"],
+  },
+  ai: { provider: "none", model: "gpt-4o", apiKeyEnv: "OPENAI_API_KEY" },
+  useCases: { dir: "./docs/use-cases", formats: ["md", "feature", "txt"] },
+};
+
+export const FRAMEWORK_DETECT_MAP = {
+  react: { deps: ["react", "react-dom"], type: "react-spa" },
+  next: { deps: ["next"], type: "nextjs" },
+  vue: { deps: ["vue"], type: "vue" },
+  angular: { deps: ["@angular/core"], type: "angular" },
+};
+
+export const RUNNER_DETECT_MAP = {
+  jest: {
+    devDeps: ["jest", "jest-cli", "@jest/core"],
+    configs: ["jest.config.js", "jest.config.ts", "jest.config.mjs"],
+  },
+  vitest: {
+    devDeps: ["vitest"],
+    configs: ["vitest.config.js", "vitest.config.ts", "vitest.config.mjs"],
+  },
+  playwright: {
+    devDeps: ["@playwright/test", "playwright"],
+    configs: ["playwright.config.js", "playwright.config.ts"],
+  },
+  cypress: {
+    devDeps: ["cypress"],
+    configs: ["cypress.config.js", "cypress.config.ts"],
+  },
+};

package/src/core/logger.js

@@ -0,0 +1,104 @@
+import chalk from "chalk";
+
+const ICONS = {
+  info: "\u2139",
+  success: "\u2713",
+  warn: "\u26a0",
+  error: "\u2717",
+  step: "\u25b8",
+  bullet: "\u2022",
+};
+
+function formatMs(ms) {
+  if (ms < 1000) return `${ms}ms`;
+  if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
+  return `${(ms / 60000).toFixed(1)}m`;
+}
+
+export const logger = {
+  info(msg) {
+    console.log(chalk.blue(`  ${ICONS.info} ${msg}`));
+  },
+  success(msg) {
+    console.log(chalk.green(`  ${ICONS.success} ${msg}`));
+  },
+  warn(msg) {
+    console.log(chalk.yellow(`  ${ICONS.warn} ${msg}`));
+  },
+  error(msg) {
+    console.log(chalk.red(`  ${ICONS.error} ${msg}`));
+  },
+
+  step(current, total, msg) {
+    console.log(
+      chalk.cyan(
+        `  ${ICONS.step} ${chalk.dim(`[${current}/${total}]`)} ${msg}`,
+      ),
+    );
+  },
+
+  dim(msg) {
+    console.log(chalk.dim(`    ${msg}`));
+  },
+  blank() {
+    console.log("");
+  },
+
+  header(title) {
+    logger.blank();
+    console.log(chalk.bold.white(`  ${title}`));
+    console.log(chalk.dim(`  ${"\u2500".repeat(50)}`));
+  },
+
+  box(title, lines) {
+    const w = 54;
+    const border = chalk.dim("\u2500".repeat(w));
+    logger.blank();
+    console.log(chalk.dim(`  \u250c${border}\u2510`));
+    console.log(
+      chalk.dim("  \u2502") +
+        chalk.bold.white(` ${title.padEnd(w - 1)}`) +
+        chalk.dim("\u2502"),
+    );
+    console.log(chalk.dim(`  \u251c${border}\u2524`));
+    for (const line of lines) {
+      const padded = `  ${line}`.padEnd(w);
+      console.log(chalk.dim("  \u2502") + padded + chalk.dim(" \u2502"));
+    }
+    console.log(chalk.dim(`  \u2514${border}\u2518`));
+    logger.blank();
+  },
+
+  table(headers, rows) {
+    const colWidths = headers.map(
+      (h, i) =>
+        Math.max(h.length, ...rows.map((r) => String(r[i] || "").length)) + 2,
+    );
+    const headerLine = headers
+      .map((h, i) => chalk.bold(h.padEnd(colWidths[i])))
+      .join("");
+    const separator = colWidths.map((w) => "\u2500".repeat(w)).join("");
+    console.log(chalk.dim("  ") + headerLine);
+    console.log(chalk.dim(`  ${separator}`));
+    for (const row of rows) {
+      const line = row
+        .map((cell, i) => String(cell || "").padEnd(colWidths[i]))
+        .join("");
+      console.log(`  ${line}`);
+    }
+  },
+
+  testResult(name, status, duration) {
+    const icon =
+      status === "passed"
+        ? chalk.green(ICONS.success)
+        : status === "failed"
+          ? chalk.red(ICONS.error)
+          : chalk.yellow("\u25cb");
+    const dur = duration ? chalk.dim(` (${formatMs(duration)})`) : "";
+    const nameStr = status === "failed" ? chalk.red(name) : name;
+    console.log(`    ${icon} ${nameStr}${dur}`);
+  },
+};
+
+export { formatMs };

package/src/executor/process-manager.js

@@ -0,0 +1,82 @@
+import { spawn } from "node:child_process";
+import treeKill from "tree-kill";
+
+export class ProcessManager {
+  async run(command, options = {}) {
+    const {
+      cwd = process.cwd(),
+      env = {},
+      timeout = 120000,
+      onStdout,
+      onStderr,
+    } = options;
+
+    return new Promise((resolve) => {
+      const startTime = Date.now();
+      let stdout = "";
+      let stderr = "";
+      let killed = false;
+
+      const mergedEnv = { ...process.env, ...env, FORCE_COLOR: "0" };
+      const isWindows = process.platform === "win32";
+
+      const child = spawn(command, {
+        cwd,
+        env: mergedEnv,
+        shell: true,
+        stdio: ["pipe", "pipe", "pipe"],
+        windowsHide: true,
+      });
+
+      const timer =
+        timeout > 0
+          ? setTimeout(() => {
+              killed = true;
+              treeKill(child.pid, "SIGTERM");
+            }, timeout)
+          : null;
+
+      child.stdout.on("data", (data) => {
+        const text = data.toString();
+        stdout += text;
+        if (onStdout) {
+          for (const line of text.split("\n").filter(Boolean)) {
+            onStdout(line);
+          }
+        }
+      });
+
+      child.stderr.on("data", (data) => {
+        const text = data.toString();
+        stderr += text;
+        if (onStderr) {
+          for (const line of text.split("\n").filter(Boolean)) {
+            onStderr(line);
+          }
+        }
+      });
+
+      child.on("close", (exitCode) => {
+        if (timer) clearTimeout(timer);
+        resolve({
+          stdout,
+          stderr,
+          exitCode: exitCode ?? 1,
+          duration: Date.now() - startTime,
+          killed,
+        });
+      });
+
+      child.on("error", (err) => {
+        if (timer) clearTimeout(timer);
+        resolve({
+          stdout,
+          stderr: stderr + "\n" + err.message,
+          exitCode: 1,
+          duration: Date.now() - startTime,
+          killed: false,
+        });
+      });
+    });
+  }
+}

package/src/executor/result-collector.js

@@ -0,0 +1,81 @@
+export class TestResult {
+  constructor(runner, layer, feature) {
+    this.runner = runner;
+    this.layer = layer;
+    this.feature = feature;
+    this.timestamp = new Date().toISOString();
+    this.duration = 0;
+    this.summary = { total: 0, passed: 0, failed: 0, skipped: 0, passRate: 0 };
+    this.tests = [];
+    this.coverage = null;
+    this.artifacts = [];
+    this.errors = [];
+    this.rawOutput = "";
+  }
+}
+
+export class ResultCollector {
+  constructor() {
+    this.results = [];
+  }
+
+  addResult(testResult) {
+    this.results.push(testResult);
+  }
+
+  getSummary() {
+    const byLayer = {};
+    const byFeature = {};
+    let totalTests = 0,
+      totalPassed = 0,
+      totalFailed = 0,
+      totalSkipped = 0,
+      totalDuration = 0;
+
+    for (const r of this.results) {
+      totalTests += r.summary.total;
+      totalPassed += r.summary.passed;
+      totalFailed += r.summary.failed;
+      totalSkipped += r.summary.skipped;
+      totalDuration += r.duration;
+
+      if (!byLayer[r.layer])
+        byLayer[r.layer] = { total: 0, passed: 0, failed: 0, skipped: 0 };
+      byLayer[r.layer].total += r.summary.total;
+      byLayer[r.layer].passed += r.summary.passed;
+      byLayer[r.layer].failed += r.summary.failed;
+      byLayer[r.layer].skipped += r.summary.skipped;
+
+      if (!byFeature[r.feature])
+        byFeature[r.feature] = { total: 0, passed: 0, failed: 0, skipped: 0 };
+      byFeature[r.feature].total += r.summary.total;
+      byFeature[r.feature].passed += r.summary.passed;
+      byFeature[r.feature].failed += r.summary.failed;
+      byFeature[r.feature].skipped += r.summary.skipped;
+    }
+
+    return {
+      totalTests,
+      totalPassed,
+      totalFailed,
+      totalSkipped,
+      overallPassRate:
+        totalTests > 0 ? Math.round((totalPassed / totalTests) * 100) : 0,
+      totalDuration,
+      byLayer,
+      byFeature,
+    };
+  }
+
+  getAllTests() {
+    return this.results.flatMap((r) => r.tests);
+  }
+
+  getFailedTests() {
+    return this.getAllTests().filter((t) => t.status === "failed");
+  }
+
+  toJSON() {
+    return { results: this.results, summary: this.getSummary() };
+  }
+}

package/src/executor/test-executor.js

@@ -0,0 +1,124 @@
+import { ProcessManager } from "./process-manager.js";
+import { ResultCollector, TestResult } from "./result-collector.js";
+import { getRunner } from "../runners/runner-registry.js";
+import { LAYERS } from "../core/constants.js";
+
+export class TestExecutor {
+  constructor(config, projectProfile) {
+    this.config = config;
+    this.profile = projectProfile;
+    this.processManager = new ProcessManager();
+    this.resultCollector = new ResultCollector();
+    this.listeners = [];
+  }
+
+  onProgress(callback) {
+    this.listeners.push(callback);
+  }
+
+  async execute(options = {}) {
+    const {
+      feature = "all",
+      layers = null,
+      env = "local",
+      coverage = false,
+      verbose = false,
+      timeout = 120000,
+    } = options;
+    const targetLayers = layers || Object.keys(this.config.layers || {});
+
+    this.emit({ type: "start", feature, layers: targetLayers, env });
+
+    for (const layerName of targetLayers) {
+      const layerConfig = this.config.layers?.[layerName];
+      if (!layerConfig) {
+        this.emit({
+          type: "layer-skip",
+          layer: layerName,
+          reason: "not configured",
+        });
+        continue;
+      }
+
+      const runner = getRunner(layerConfig.runner, layerConfig);
+      this.emit({
+        type: "layer-start",
+        layer: layerName,
+        runner: runner.getDisplayName(),
+      });
+
+      const command = runner.buildCommand({
+        pattern: feature !== "all" ? feature : "",
+        coverage,
+        verbose,
+        env: this.config.environments?.[env],
+      });
+
+      const result = await this.processManager.run(command, {
+        cwd: this.profile.paths.root,
+        timeout,
+        onStdout: (line) =>
+          this.emit({ type: "stdout", layer: layerName, line }),
+        onStderr: (line) =>
+          this.emit({ type: "stderr", layer: layerName, line }),
+      });
+
+      const parsed = runner.parseOutput(
+        result.stdout,
+        result.stderr,
+        result.exitCode,
+      );
+
+      const testResult = new TestResult(runner.name, layerName, feature);
+      testResult.duration = result.duration;
+      testResult.summary = parsed.summary;
+      testResult.tests = parsed.tests;
+      testResult.coverage = parsed.coverage;
+      testResult.rawOutput = verbose ? result.stdout : "";
+
+      if (result.killed) {
+        testResult.errors.push({
+          message: `Timed out after ${timeout}ms`,
+          type: "timeout",
+        });
+      }
+
+      this.resultCollector.addResult(testResult);
+
+      for (const test of parsed.tests) {
+        this.emit({
+          type:
+            test.status === "passed"
+              ? "test-pass"
+              : test.status === "failed"
+                ? "test-fail"
+                : "test-skip",
+          layer: layerName,
+          test,
+        });
+      }
+
+      this.emit({
+        type: "layer-end",
+        layer: layerName,
+        summary: parsed.summary,
+        duration: result.duration,
+      });
+    }
+
+    const summary = this.resultCollector.getSummary();
+    this.emit({ type: "complete", summary });
+
+    return this.resultCollector;
+  }
+
+  emit(event) {
+    for (const cb of this.listeners) {
+      try {
+        cb(event);
+      } catch {
+        /* listener error should not break execution */
+      }
+    }
+  }
+}

package/src/index.js

@@ -0,0 +1,12 @@
+export { loadConfig, writeConfig, validateConfig } from "./core/config.js";
+export { logger } from "./core/logger.js";
+export { analyzeProject } from "./analyzers/project-analyzer.js";
+export { detectTests } from "./analyzers/test-detector.js";
+export { detectFeatures } from "./analyzers/feature-detector.js";
+export { detectEnvironments } from "./analyzers/env-detector.js";
+export { TestExecutor } from "./executor/test-executor.js";
+export { ResultCollector, TestResult } from "./executor/result-collector.js";
+export { ReportGenerator } from "./reporter/report-generator.js";
+export { AIEngine } from "./ai/ai-engine.js";
+export { getRunner, listRunners } from "./runners/runner-registry.js";
+export { VERSION, TOOL_NAME } from "./core/constants.js";

package/src/reporter/html-builder.js

@@ -0,0 +1,149 @@
+import { formatMs } from "../core/logger.js";
+
+export class HtmlBuilder {
+  render(results, meta) {
+    const summary = results.summary || {};
+    const allTests = (results.results || []).flatMap((r) => r.tests || []);
+    const failedTests = allTests.filter((t) => t.status === "failed");
+    const passedTests = allTests.filter((t) => t.status === "passed");
+    const skippedTests = allTests.filter((t) => t.status === "skipped");
+
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>QABot Report - ${esc(meta.feature || "all")} | ${esc(meta.projectName || "")}</title>
+<style>
+*{margin:0;padding:0;box-sizing:border-box}
+:root{--bg:#0f172a;--card:#1e293b;--card-hover:#273548;--border:#334155;--text:#e2e8f0;--text-dim:#94a3b8;--accent:#3b82f6;--green:#22c55e;--red:#ef4444;--yellow:#eab308;--font:system-ui,-apple-system,sans-serif;--mono:'SF Mono',SFMono-Regular,Menlo,monospace}
+body{background:var(--bg);color:var(--text);font-family:var(--font);line-height:1.6;padding:2rem}
+.container{max-width:1200px;margin:0 auto}
+h1{font-size:1.8rem;font-weight:700;margin-bottom:.5rem}
+h2{font-size:1.3rem;font-weight:600;margin:2rem 0 1rem;color:var(--accent)}
+.subtitle{color:var(--text-dim);font-size:.9rem;margin-bottom:2rem}
+.cards{display:grid;grid-template-columns:repeat(auto-fit,minmax(180px,1fr));gap:1rem;margin-bottom:2rem}
+.card{background:var(--card);border:1px solid var(--border);border-radius:12px;padding:1.5rem;text-align:center}
+.card .value{font-size:2rem;font-weight:700;margin:.5rem 0}
+.card .label{color:var(--text-dim);font-size:.85rem;text-transform:uppercase;letter-spacing:.05em}
+.card.pass .value{color:var(--green)}
+.card.fail .value{color:var(--red)}
+.card.skip .value{color:var(--yellow)}
+.card.rate .value{color:var(--accent)}
+.badge{display:inline-block;padding:2px 10px;border-radius:999px;font-size:.75rem;font-weight:600}
+.badge-pass{background:#22c55e22;color:var(--green)}
+.badge-fail{background:#ef444422;color:var(--red)}
+.badge-skip{background:#eab30822;color:var(--yellow)}
+.bar{height:8px;background:var(--border);border-radius:4px;overflow:hidden;margin:1rem 0}
+.bar-fill{height:100%;border-radius:4px;transition:width .5s}
+.bar-green{background:var(--green)}
+.bar-red{background:var(--red)}
+table{width:100%;border-collapse:collapse;margin:1rem 0}
+th{text-align:left;padding:.75rem 1rem;border-bottom:2px solid var(--border);color:var(--text-dim);font-size:.8rem;text-transform:uppercase;letter-spacing:.05em}
+td{padding:.75rem 1rem;border-bottom:1px solid var(--border)}
+tr:hover td{background:var(--card-hover)}
+.error-box{background:#1a0000;border:1px solid #ef444444;border-radius:8px;padding:1rem;margin:.5rem 0;font-family:var(--mono);font-size:.8rem;color:#fca5a5;white-space:pre-wrap;overflow-x:auto;max-height:200px;overflow-y:auto}
+.filters{display:flex;gap:.5rem;margin:1rem 0}
+.filter-btn{background:var(--card);border:1px solid var(--border);color:var(--text);padding:.4rem 1rem;border-radius:8px;cursor:pointer;font-size:.85rem;transition:all .2s}
+.filter-btn:hover,.filter-btn.active{background:var(--accent);border-color:var(--accent);color:#fff}
+.layer-section{background:var(--card);border:1px solid var(--border);border-radius:12px;padding:1.5rem;margin:1rem 0}
+.collapsible{cursor:pointer;user-select:none}
+.collapsible::after{content:' \\25BC';font-size:.7rem;color:var(--text-dim)}
+.hidden{display:none}
+footer{margin-top:3rem;padding-top:1rem;border-top:1px solid var(--border);color:var(--text-dim);font-size:.8rem;text-align:center}
+</style>
+</head>
+<body>
+<div class="container">
+<h1>QABot Test Report</h1>
+<div class="subtitle">${esc(meta.projectName || "")} &bull; Feature: ${esc(meta.feature || "all")} &bull; Env: ${esc(meta.environment || "local")} &bull; ${esc(meta.timestamp?.slice(0, 19) || "")}</div>
+
+<div class="cards">
+  <div class="card"><div class="label">Total Tests</div><div class="value">${summary.totalTests || 0}</div></div>
+  <div class="card pass"><div class="label">Passed</div><div class="value">${summary.totalPassed || 0}</div></div>
+  <div class="card fail"><div class="label">Failed</div><div class="value">${summary.totalFailed || 0}</div></div>
+  <div class="card skip"><div class="label">Skipped</div><div class="value">${summary.totalSkipped || 0}</div></div>
+  <div class="card rate"><div class="label">Pass Rate</div><div class="value">${summary.overallPassRate || 0}%</div></div>
+  <div class="card"><div class="label">Duration</div><div class="value">${formatMs(meta.duration || summary.totalDuration || 0)}</div></div>
+</div>
+
+<div class="bar"><div class="bar-fill ${(summary.overallPassRate || 0) >= 80 ? "bar-green" : "bar-red"}" style="width:${summary.overallPassRate || 0}%"></div></div>
+
+${Object.entries(summary.byLayer || {})
+  .map(
+    ([layer, s]) => `
+<h2>${layer.charAt(0).toUpperCase() + layer.slice(1)} Tests</h2>
+<div class="layer-section">
+  <div>${s.passed} passed, ${s.failed} failed, ${s.skipped} skipped of ${s.total}</div>
+</div>
+`,
+  )
+  .join("")}
+
+<h2>All Test Results</h2>
+<div class="filters">
+  <button class="filter-btn active" onclick="filterTests('all')">All (${allTests.length})</button>
+  <button class="filter-btn" onclick="filterTests('passed')">Passed (${passedTests.length})</button>
+  <button class="filter-btn" onclick="filterTests('failed')">Failed (${failedTests.length})</button>
+  <button class="filter-btn" onclick="filterTests('skipped')">Skipped (${skippedTests.length})</button>
+</div>
+
+<table>
+<thead><tr><th>Status</th><th>Test Name</th><th>Suite</th><th>Duration</th></tr></thead>
+<tbody>
+${allTests
+  .map(
+    (t) => `<tr class="test-row" data-status="${t.status}">
+  <td><span class="badge badge-${t.status}">${t.status}</span></td>
+  <td>${esc(t.name)}${t.error ? `<div class="error-box">${esc(t.error.message || "")}</div>` : ""}</td>
+  <td style="color:var(--text-dim);font-size:.85rem">${esc(t.suite || t.file || "")}</td>
+  <td style="color:var(--text-dim)">${formatMs(t.duration || 0)}</td>
+</tr>`,
+  )
+  .join("\n")}
+</tbody>
+</table>
+
+${
+  failedTests.length > 0
+    ? `
+<h2>Failed Test Details</h2>
+${failedTests
+  .map(
+    (t) => `
+<div class="layer-section">
+  <strong style="color:var(--red)">${esc(t.name)}</strong>
+  <div style="color:var(--text-dim);font-size:.85rem;margin:.5rem 0">${esc(t.file || "")} &bull; ${esc(t.suite || "")}</div>
+  ${t.error ? `<div class="error-box">${esc(t.error.message || "")}\n${esc(t.error.stack || "")}</div>` : ""}
+</div>
+`,
+  )
+  .join("")}
+`
+    : ""
+}
+
+<footer>Generated by QABot v0.1.0 &bull; ${new Date().toISOString()}</footer>
+</div>
+
+<script>
+function filterTests(status){
+  document.querySelectorAll('.filter-btn').forEach(b=>b.classList.remove('active'));
+  event.target.classList.add('active');
+  document.querySelectorAll('.test-row').forEach(r=>{
+    r.style.display=status==='all'||r.dataset.status===status?'':'none';
+  });
+}
+</script>
+</body>
+</html>`;
+  }
+}
+
+function esc(str) {
+  return String(str || "")
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;");
+}