@nhonh/qabot 0.1.0

package/src/cli/commands/generate.js

@@ -0,0 +1,125 @@
+import chalk from "chalk";
+import ora from "ora";
+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 { findFiles, safeReadFile } from "../../utils/file-utils.js";
+
+export function registerGenerateCommand(program) {
+  program
+    .command("generate [feature]")
+    .description("Generate test cases and code using AI")
+    .option("-l, --layer <layer>", "Target layer (unit, integration, e2e)")
+    .option("--use-cases <dir>", "Directory containing use case documents")
+    .option("--dry-run", "Show plan without writing files")
+    .option("--model <model>", "AI model to use")
+    .option("-d, --dir <path>", "Project directory", process.cwd())
+    .action(runGenerate);
+}
+
+async function runGenerate(feature, options) {
+  const projectDir = options.dir;
+  const { config, isEmpty } = await loadConfig(projectDir);
+
+  if (isEmpty) {
+    logger.warn("No qabot.config.js found. Run `qabot init` first.");
+    return;
+  }
+
+  const aiConfig = { ...config.ai };
+  if (options.model) aiConfig.model = options.model;
+
+  const ai = new AIEngine(aiConfig);
+  if (!ai.isAvailable()) {
+    logger.error("AI is not configured. Set your API key:");
+    logger.dim(`  export ${aiConfig.apiKeyEnv || "OPENAI_API_KEY"}=your-key`);
+    logger.dim("  Or update qabot.config.js ai.provider setting.");
+    return;
+  }
+
+  const profile = await analyzeProject(projectDir);
+  logger.header("QABot \u2014 AI Test Generation");
+
+  const spinner = ora("Analyzing feature source code...").start();
+
+  const featureConfig = config.features?.[feature];
+  if (!featureConfig) {
+    spinner.fail(
+      `Feature "${feature}" not found in config. Run \`qabot list features\` to see available.`,
+    );
+    return;
+  }
+
+  const sourceFiles = await findFiles(
+    projectDir,
+    `${featureConfig.src}/**/*.{js,jsx,ts,tsx}`,
+  );
+  const sourceCode = (
+    await Promise.all(sourceFiles.slice(0, 10).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) {
+      const parsed = await parser.parse(f);
+      useCases.push(...parsed);
+    }
+  }
+
+  spinner.text = "AI is analyzing code and generating test plan...";
+
+  try {
+    const testPlan = await ai.analyzeCode(sourceCode, {
+      framework: profile.techStack.framework,
+      runner: config.layers?.[options.layer || "unit"]?.runner || "jest",
+      existingTestCount: 0,
+      useCases,
+    });
+
+    spinner.succeed("Test plan generated");
+    logger.blank();
+
+    if (Array.isArray(testPlan)) {
+      logger.info(
+        `Generated ${chalk.bold(testPlan.length)} test cases for "${feature}":`,
+      );
+      logger.blank();
+      for (const tc of testPlan) {
+        const icon =
+          tc.priority === "P0"
+            ? chalk.red("\u25cf")
+            : tc.priority === "P1"
+              ? chalk.yellow("\u25cf")
+              : chalk.blue("\u25cf");
+        console.log(`    ${icon} ${chalk.bold(tc.name)}`);
+        logger.dim(`      ${tc.description}`);
+        logger.dim(`      Type: ${tc.type} | Priority: ${tc.priority}`);
+      }
+    }
+
+    if (options.dryRun) {
+      logger.blank();
+      logger.info("Dry run complete. No files written.");
+      return;
+    }
+
+    logger.blank();
+    logger.info("Test code generation coming in next version.");
+    logger.dim(
+      "For now, use the test plan above as a guide to write tests manually.",
+    );
+  } catch (err) {
+    spinner.fail("AI analysis failed");
+    logger.error(err.message);
+  }
+}

package/src/cli/commands/init.js

@@ -0,0 +1,137 @@
+import ora from "ora";
+import Enquirer from "enquirer";
+import { logger } from "../../core/logger.js";
+import { writeConfig } from "../../core/config.js";
+import { analyzeProject } from "../../analyzers/project-analyzer.js";
+import { detectTests } from "../../analyzers/test-detector.js";
+import { detectFeatures } from "../../analyzers/feature-detector.js";
+import { detectEnvironments } from "../../analyzers/env-detector.js";
+import { DEFAULT_CONFIG } from "../../core/constants.js";
+
+export function registerInitCommand(program) {
+  program
+    .command("init")
+    .description("Initialize QABot for current project")
+    .option("-y, --yes", "Accept all defaults without prompting")
+    .option("-d, --dir <path>", "Project directory", process.cwd())
+    .action(runInit);
+}
+
+async function runInit(options) {
+  const projectDir = options.dir;
+  const spinner = ora("Analyzing project...").start();
+
+  try {
+    const profile = await analyzeProject(projectDir);
+    const testInfo = await detectTests(projectDir, profile);
+    const features = await detectFeatures(projectDir, profile);
+    const envInfo = await detectEnvironments(projectDir);
+    spinner.succeed("Project analysis complete");
+
+    logger.blank();
+    logger.box("QABot - Project Analysis", [
+      `Project:    ${profile.name}`,
+      `Type:       ${profile.type}`,
+      `Language:   ${profile.techStack.language}`,
+      `Framework:  ${profile.techStack.framework || "none"}`,
+      `Bundler:    ${profile.techStack.bundler || "none"}`,
+      `State:      ${profile.techStack.stateManagement || "none"}`,
+      `Auth:       ${profile.techStack.authProvider || "none"}`,
+      `Pkg Mgr:    ${profile.packageManager}`,
+      ``,
+      `Test Frameworks: ${testInfo.frameworks.map((f) => f.name).join(", ") || "none"}`,
+      `Unit Tests:      ${testInfo.testFiles.unit.count} files`,
+      `E2E Tests:       ${testInfo.testFiles.e2e.count} files`,
+      `Pages:           ${features.pages.length}`,
+      `Features:        ${features.features.length}`,
+      `Environments:    ${Object.keys(envInfo.environments).length}`,
+    ]);
+
+    const configData = buildConfigFromAnalysis(
+      profile,
+      testInfo,
+      features,
+      envInfo,
+    );
+
+    if (!options.yes) {
+      const enquirer = new Enquirer();
+      const { proceed } = await enquirer.prompt({
+        type: "confirm",
+        name: "proceed",
+        message: "Generate qabot.config.js with these settings?",
+        initial: true,
+      });
+      if (!proceed) {
+        logger.warn("Cancelled. Run `qabot init` again to retry.");
+        return;
+      }
+    }
+
+    const configPath = await writeConfig(projectDir, configData);
+    logger.blank();
+    logger.success(`Config written to ${configPath}`);
+    logger.blank();
+    logger.info("Next steps:");
+    logger.dim("  qabot list          - View detected features and test info");
+    logger.dim("  qabot run           - Run all tests");
+    logger.dim("  qabot run auth      - Run tests for a specific feature");
+    logger.dim("  qabot generate auth - AI-generate tests for a feature");
+    logger.blank();
+  } catch (err) {
+    spinner.fail("Analysis failed");
+    logger.error(err.message);
+    process.exit(1);
+  }
+}
+
+function buildConfigFromAnalysis(profile, testInfo, features, envInfo) {
+  const config = {
+    project: { name: profile.name, type: profile.type },
+    environments: {},
+    layers: {},
+    features: {},
+    ...DEFAULT_CONFIG,
+  };
+
+  for (const [name, env] of Object.entries(envInfo.environments)) {
+    config.environments[name] = { url: env.url || "" };
+  }
+
+  for (const fw of testInfo.frameworks) {
+    if (fw.name === "playwright" || fw.name === "cypress") {
+      config.layers.e2e = {
+        runner: fw.name,
+        command: `npx ${fw.name} test {pattern}`,
+        testDir: "e2e/tests",
+      };
+    } else {
+      config.layers.unit = {
+        runner: fw.name,
+        command: testInfo.scripts.test || `npx ${fw.name} {pattern}`,
+        testMatch: testInfo.testFiles.unit.pattern || "**/*.test.*",
+      };
+    }
+  }
+
+  for (const f of features.features) {
+    config.features[f.name] = { src: f.path, priority: "P1" };
+  }
+  for (const p of features.pages) {
+    const name = p.name
+      .replace(/^Page/, "")
+      .replace(/([A-Z])/g, "-$1")
+      .toLowerCase()
+      .replace(/^-/, "");
+    config.features[name] = { src: p.path, priority: "P1" };
+  }
+
+  if (profile.techStack.authProvider) {
+    config.auth = {
+      provider: profile.techStack.authProvider,
+      credentials: { email: "E2E_TEST_EMAIL", password: "E2E_TEST_PASSWORD" },
+    };
+  }
+
+  return config;
+}

package/src/cli/commands/list.js

@@ -0,0 +1,130 @@
+import { logger } from "../../core/logger.js";
+import { loadConfig } from "../../core/config.js";
+import { analyzeProject } from "../../analyzers/project-analyzer.js";
+import { detectTests } from "../../analyzers/test-detector.js";
+import { detectFeatures } from "../../analyzers/feature-detector.js";
+import { detectEnvironments } from "../../analyzers/env-detector.js";
+
+export function registerListCommand(program) {
+  program
+    .command("list [type]")
+    .description(
+      "List detected project info (features, envs, layers, tests, all)",
+    )
+    .option("-d, --dir <path>", "Project directory", process.cwd())
+    .action(runList);
+}
+
+async function runList(type = "all", options) {
+  const projectDir = options.dir;
+  const { config, isEmpty } = await loadConfig(projectDir);
+  const profile = await analyzeProject(projectDir);
+  const testInfo = await detectTests(projectDir, profile);
+  const features = await detectFeatures(projectDir, profile);
+  const envInfo = await detectEnvironments(projectDir);
+
+  const sections = {
+    features: () => listFeatures(config, features),
+    envs: () => listEnvironments(config, envInfo),
+    layers: () => listLayers(config, testInfo),
+    tests: () => listTests(testInfo),
+    all: () => {
+      listFeatures(config, features);
+      listEnvironments(config, envInfo);
+      listLayers(config, testInfo);
+      listTests(testInfo);
+    },
+  };
+
+  if (!sections[type]) {
+    logger.error(
+      `Unknown list type: ${type}. Use: features, envs, layers, tests, all`,
+    );
+    return;
+  }
+
+  logger.header(`QABot - ${type === "all" ? "Project Overview" : type}`);
+  sections[type]();
+  logger.blank();
+}
+
+function listFeatures(config, features) {
+  logger.blank();
+  logger.info("Features & Pages");
+  const rows = [];
+  if (config.features) {
+    for (const [name, f] of Object.entries(config.features)) {
+      rows.push([name, f.src || "-", f.priority || "P1"]);
+    }
+  } else {
+    for (const f of features.features) rows.push([f.name, f.path, "P1"]);
+    for (const p of features.pages) rows.push([p.name, p.path, "P1"]);
+  }
+  if (rows.length === 0) {
+    logger.dim("No features detected");
+    return;
+  }
+  logger.table(["Name", "Source Path", "Priority"], rows);
+}
+
+function listEnvironments(config, envInfo) {
+  logger.blank();
+  logger.info("Environments");
+  const envs = config.environments || envInfo.environments;
+  const rows = Object.entries(envs).map(([name, e]) => [
+    name,
+    e.url || "-",
+    e.vpn ? "Yes" : "No",
+  ]);
+  if (rows.length === 0) {
+    logger.dim("No environments detected");
+    return;
+  }
+  logger.table(["Name", "URL", "VPN"], rows);
+}
+
+function listLayers(config, testInfo) {
+  logger.blank();
+  logger.info("Test Layers");
+  const layers = config.layers || {};
+  const rows = Object.entries(layers).map(([name, l]) => [
+    name,
+    l.runner || "-",
+    l.command || "-",
+  ]);
+  if (rows.length === 0) {
+    const fwRows = testInfo.frameworks.map((f) => [
+      f.name,
+      f.version,
+      f.configFile || "-",
+    ]);
+    if (fwRows.length > 0)
+      logger.table(["Framework", "Version", "Config"], fwRows);
+    else logger.dim("No test layers configured");
+    return;
+  }
+  logger.table(["Layer", "Runner", "Command"], rows);
+}
+
+function listTests(testInfo) {
+  logger.blank();
+  logger.info("Existing Tests");
+  const rows = [
+    [
+      "Unit",
+      String(testInfo.testFiles.unit.count),
+      testInfo.testFiles.unit.pattern || "-",
+    ],
+    [
+      "Integration",
+      String(testInfo.testFiles.integration.count),
+      testInfo.testFiles.integration.pattern || "-",
+    ],
+    [
+      "E2E",
+      String(testInfo.testFiles.e2e.count),
+      testInfo.testFiles.e2e.pattern || "-",
+    ],
+  ];
+  logger.table(["Layer", "Files", "Pattern"], rows);
+}

package/src/cli/commands/report.js

@@ -0,0 +1,46 @@
+import { logger } from "../../core/logger.js";
+import { loadConfig } from "../../core/config.js";
+import { ReportGenerator } from "../../reporter/report-generator.js";
+
+export function registerReportCommand(program) {
+  program
+    .command("report")
+    .description("Open the latest test report or list all reports")
+    .option("--list", "List all available reports")
+    .option("--open <path>", "Open a specific report")
+    .option("-d, --dir <path>", "Project directory", process.cwd())
+    .action(runReport);
+}
+
+async function runReport(options) {
+  const { config } = await loadConfig(options.dir);
+  const reporter = new ReportGenerator(config);
+
+  if (options.list) {
+    const reports = await reporter.listReports();
+    if (reports.length === 0) {
+      logger.info("No reports found. Run `qabot run` first.");
+      return;
+    }
+    logger.header("QABot - Reports");
+    logger.table(
+      ["Date", "Feature", "Pass Rate", "Path"],
+      reports.map((r) => [r.date, r.feature, `${r.passRate}%`, r.path]),
+    );
+    logger.blank();
+    return;
+  }
+
+  if (options.open) {
+    const { openInBrowser } = await import("../../reporter/report-server.js");
+    await openInBrowser(options.open);
+    return;
+  }
+
+  try {
+    await reporter.openLatest();
+  } catch (err) {
+    logger.error(`Could not open report: ${err.message}`);
+    logger.dim("Run `qabot run` first to generate a report.");
+  }
+}

package/src/cli/commands/run.js

@@ -0,0 +1,132 @@
+import chalk from "chalk";
+import { logger, formatMs } from "../../core/logger.js";
+import { loadConfig } from "../../core/config.js";
+import { analyzeProject } from "../../analyzers/project-analyzer.js";
+import { TestExecutor } from "../../executor/test-executor.js";
+import { ReportGenerator } from "../../reporter/report-generator.js";
+
+export function registerRunCommand(program) {
+  program
+    .command("run [feature]")
+    .description("Run tests for a feature or all features")
+    .option(
+      "-l, --layer <layers...>",
+      "Test layers to run (unit, integration, e2e)",
+    )
+    .option(
+      "-e, --env <environment>",
+      "Target environment for E2E tests",
+      "local",
+    )
+    .option("--coverage", "Generate coverage report")
+    .option("--verbose", "Show detailed output")
+    .option("--timeout <ms>", "Timeout per test suite in ms", "120000")
+    .option("--no-report", "Skip report generation")
+    .option("-d, --dir <path>", "Project directory", process.cwd())
+    .action(runTests);
+}
+
+async function runTests(feature, options) {
+  const projectDir = options.dir;
+  const { config, isEmpty } = await loadConfig(projectDir);
+
+  if (isEmpty) {
+    logger.warn("No qabot.config.js found. Run `qabot init` first.");
+    logger.dim("Or run tests with: qabot init -y && qabot run");
+    return;
+  }
+
+  const profile = await analyzeProject(projectDir);
+
+  const executor = new TestExecutor(config, profile);
+  executor.onProgress(createProgressHandler(options.verbose));
+
+  logger.header("QABot \u2014 Running Tests");
+  logger.blank();
+  logger.info(`Feature:     ${chalk.bold(feature || "all")}`);
+  logger.info(`Environment: ${chalk.bold(options.env)}`);
+  logger.info(
+    `Layers:      ${chalk.bold((options.layer || Object.keys(config.layers || {})).join(", "))}`,
+  );
+  logger.blank();
+  console.log(chalk.dim(`  ${"\u2500".repeat(50)}`));
+  logger.blank();
+
+  const startTime = Date.now();
+
+  const collector = await executor.execute({
+    feature: feature || "all",
+    layers: options.layer,
+    env: options.env,
+    coverage: options.coverage,
+    verbose: options.verbose,
+    timeout: parseInt(options.timeout),
+  });
+
+  const totalDuration = Date.now() - startTime;
+  const summary = collector.getSummary();
+
+  logger.blank();
+  console.log(chalk.dim(`  ${"\u2500".repeat(50)}`));
+  logger.blank();
+
+  const passColor = summary.totalFailed === 0 ? chalk.green : chalk.red;
+  logger.info(
+    `Summary: ${chalk.green(`${summary.totalPassed} passed`)}, ${summary.totalFailed > 0 ? chalk.red(`${summary.totalFailed} failed`) : `${summary.totalFailed} failed`}, ${chalk.yellow(`${summary.totalSkipped} skipped`)} ${chalk.dim(`(${formatMs(totalDuration)})`)}`,
+  );
+
+  if (options.report !== false) {
+    try {
+      const reporter = new ReportGenerator(config);
+      const reportPaths = await reporter.generate(collector.toJSON(), {
+        feature: feature || "all",
+        environment: options.env,
+        projectName: profile.name,
+        timestamp: new Date().toISOString(),
+        duration: totalDuration,
+      });
+      logger.info(`Report: ${chalk.underline(reportPaths.htmlPath)}`);
+    } catch (err) {
+      logger.warn(`Report generation failed: ${err.message}`);
+    }
+  }
+
+  logger.blank();
+  if (summary.totalFailed > 0) process.exit(1);
+}
+
+function createProgressHandler(verbose) {
+  return (event) => {
+    switch (event.type) {
+      case "layer-start":
+        logger.blank();
+        logger.info(`${chalk.bold(event.runner)} (${event.layer})`);
+        break;
+      case "layer-skip":
+        logger.dim(`  Skipping ${event.layer}: ${event.reason}`);
+        break;
+      case "test-pass":
+        logger.testResult(event.test.name, "passed", event.test.duration);
+        break;
+      case "test-fail":
+        logger.testResult(event.test.name, "failed", event.test.duration);
+        if (event.test.error?.message) {
+          logger.dim(
+            `      ${chalk.red(event.test.error.message.split("\n")[0])}`,
+          );
+        }
+        break;
+      case "test-skip":
+        if (verbose) logger.testResult(event.test.name, "skipped", 0);
+        break;
+      case "layer-end":
+        logger.dim(
+          `  ${event.summary.passed} passed, ${event.summary.failed} failed (${formatMs(event.duration)})`,
+        );
+        break;
+      case "stdout":
+        if (verbose) console.log(chalk.dim(`    ${event.line}`));
+        break;
+    }
+  };
+}

package/src/core/config.js

@@ -0,0 +1,71 @@
+import { cosmiconfig } from "cosmiconfig";
+import path from "node:path";
+import { writeFile } from "node:fs/promises";
+import { DEFAULT_CONFIG, TOOL_NAME } from "./constants.js";
+
+const explorer = cosmiconfig(TOOL_NAME, {
+  searchPlaces: [
+    "qabot.config.js",
+    "qabot.config.mjs",
+    "qabot.config.cjs",
+    ".qabotrc.json",
+    ".qabotrc.js",
+    "package.json",
+  ],
+});
+
+export async function loadConfig(projectDir) {
+  try {
+    const result = await explorer.search(projectDir || process.cwd());
+    if (!result || result.isEmpty) {
+      return { config: { ...DEFAULT_CONFIG }, configPath: null, isEmpty: true };
+    }
+    const merged = deepMerge(DEFAULT_CONFIG, result.config);
+    return { config: merged, configPath: result.filepath, isEmpty: false };
+  } catch (err) {
+    return {
+      config: { ...DEFAULT_CONFIG },
+      configPath: null,
+      isEmpty: true,
+      error: err.message,
+    };
+  }
+}
+
+export async function writeConfig(projectDir, configData) {
+  const configPath = path.join(projectDir, "qabot.config.js");
+  const lines = [
+    "export default " + JSON.stringify(configData, null, 2) + ";\n",
+  ];
+  await writeFile(configPath, lines.join(""), "utf-8");
+  return configPath;
+}
+
+export function validateConfig(config) {
+  const errors = [];
+  if (!config.project?.name) errors.push("project.name is required");
+  if (!config.project?.type) errors.push("project.type is required");
+  if (config.layers) {
+    for (const [layer, lc] of Object.entries(config.layers)) {
+      if (!lc.runner) errors.push(`layers.${layer}.runner is required`);
+      if (!lc.command) errors.push(`layers.${layer}.command is required`);
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    if (
+      source[key] &&
+      typeof source[key] === "object" &&
+      !Array.isArray(source[key])
+    ) {
+      result[key] = deepMerge(result[key] || {}, source[key]);
+    } else {
+      result[key] = source[key];
+    }
+  }
+  return result;
+}