@nhonh/qabot 0.1.0

package/bin/qabot.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+
+import { Command } from "commander";
+import { VERSION, TOOL_NAME } from "../src/core/constants.js";
+import { registerInitCommand } from "../src/cli/commands/init.js";
+import { registerRunCommand } from "../src/cli/commands/run.js";
+import { registerListCommand } from "../src/cli/commands/list.js";
+import { registerGenerateCommand } from "../src/cli/commands/generate.js";
+import { registerReportCommand } from "../src/cli/commands/report.js";
+
+const program = new Command();
+
+program
+  .name(TOOL_NAME)
+  .description("AI-powered universal QA automation tool")
+  .version(VERSION);
+
+registerInitCommand(program);
+registerRunCommand(program);
+registerListCommand(program);
+registerGenerateCommand(program);
+registerReportCommand(program);
+
+program.parse();

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@nhonh/qabot",
+  "version": "0.1.0",
+  "description": "AI-powered universal QA automation tool. Import any project, AI analyzes and runs tests across all layers.",
+  "main": "src/index.js",
+  "bin": {
+    "qabot": "bin/qabot.js"
+  },
+  "type": "module",
+  "scripts": {
+    "start": "node bin/qabot.js",
+    "dev": "node --watch bin/qabot.js",
+    "test": "node --test tests/core/*.test.js tests/executor/*.test.js tests/runners/*.test.js tests/analyzers/*.test.js tests/ai/*.test.js tests/reporter/*.test.js",
+    "lint": "eslint src/",
+    "prepublishOnly": "npm test"
+  },
+  "keywords": [
+    "qa",
+    "testing",
+    "automation",
+    "ai",
+    "playwright",
+    "jest",
+    "vitest",
+    "e2e",
+    "unit-test",
+    "test-runner",
+    "test-report",
+    "cli"
+  ],
+  "author": "GearGames",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "cosmiconfig": "^9.0.0",
+    "enquirer": "^2.4.1",
+    "glob": "^11.0.0",
+    "handlebars": "^4.7.8",
+    "nanoid": "^5.0.9",
+    "ora": "^8.1.1",
+    "strip-ansi": "^7.1.0",
+    "tree-kill": "^1.2.2"
+  },
+  "devDependencies": {
+    "eslint": "^9.0.0"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "templates/"
+  ]
+}

package/src/ai/ai-engine.js

@@ -0,0 +1,114 @@
+import {
+  buildAnalysisPrompt,
+  buildGenerationPrompt,
+  buildRecommendationPrompt,
+} from "./prompt-builder.js";
+
+export class AIEngine {
+  constructor(config = {}) {
+    this.provider = config.provider || "none";
+    this.model = config.model || "gpt-4o";
+    this.apiKey = process.env[config.apiKeyEnv || "OPENAI_API_KEY"] || "";
+  }
+
+  isAvailable() {
+    return this.provider !== "none" && !!this.apiKey;
+  }
+
+  async analyzeCode(code, context) {
+    const prompt = buildAnalysisPrompt(code, context);
+    const response = await this.complete(prompt);
+    try {
+      return JSON.parse(response);
+    } catch {
+      return [
+        {
+          name: "Parse error",
+          description: response,
+          type: "unit",
+          priority: "P1",
+        },
+      ];
+    }
+  }
+
+  async generateTestCode(testCases, context) {
+    const prompt = buildGenerationPrompt(testCases, context);
+    return this.complete(prompt);
+  }
+
+  async generateRecommendations(results) {
+    const prompt = buildRecommendationPrompt(results);
+    return this.complete(prompt);
+  }
+
+  async complete(prompt) {
+    switch (this.provider) {
+      case "openai":
+        return this.callOpenAI(prompt);
+      case "anthropic":
+        return this.callAnthropic(prompt);
+      case "ollama":
+        return this.callOllama(prompt);
+      default:
+        throw new Error(
+          `AI provider "${this.provider}" not configured. Set provider in qabot.config.js`,
+        );
+    }
+  }
+
+  async callOpenAI(prompt) {
+    const res = await fetch("https://api.openai.com/v1/chat/completions", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`,
+      },
+      body: JSON.stringify({
+        model: this.model,
+        messages: [{ role: "user", content: prompt }],
+        temperature: 0.3,
+        max_tokens: 4096,
+      }),
+    });
+    if (!res.ok)
+      throw new Error(`OpenAI API error: ${res.status} ${await res.text()}`);
+    const data = await res.json();
+    return data.choices?.[0]?.message?.content || "";
+  }
+
+  async callAnthropic(prompt) {
+    const res = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": this.apiKey,
+        "anthropic-version": "2023-06-01",
+      },
+      body: JSON.stringify({
+        model: this.model || "claude-sonnet-4-20250514",
+        max_tokens: 4096,
+        messages: [{ role: "user", content: prompt }],
+      }),
+    });
+    if (!res.ok)
+      throw new Error(`Anthropic API error: ${res.status} ${await res.text()}`);
+    const data = await res.json();
+    return data.content?.[0]?.text || "";
+  }
+
+  async callOllama(prompt) {
+    const res = await fetch("http://localhost:11434/api/generate", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: this.model || "llama3",
+        prompt,
+        stream: false,
+      }),
+    });
+    if (!res.ok) throw new Error(`Ollama API error: ${res.status}`);
+    const data = await res.json();
+    return data.response || "";
+  }
+}

package/src/ai/prompt-builder.js

@@ -0,0 +1,86 @@
+export function buildAnalysisPrompt(code, context) {
+  const useCaseSection = context.useCases?.length
+    ? `\n## Use Cases from QA Team\n${context.useCases.map((uc) => `- Scenario: ${uc.scenario}\n  Steps: ${uc.steps.join(" -> ")}`).join("\n")}\n`
+    : "";
+
+  return `You are a senior QA engineer analyzing source code to identify test cases.
+
+## Project Context
+- Framework: ${context.framework || "unknown"}
+- Test Runner: ${context.runner || "jest"}
+- Existing Test Count: ${context.existingTestCount || 0}
+${useCaseSection}
+## Source Code
+\`\`\`
+${truncate(code, 8000)}
+\`\`\`
+
+## Task
+Analyze the code and return a JSON array of test cases. Each test case:
+{
+  "name": "descriptive test name using should/when pattern",
+  "type": "unit | integration | e2e",
+  "priority": "P0 | P1 | P2",
+  "description": "what this test verifies and why",
+  "assertions": ["list of specific things to assert"]
+}
+
+Focus on:
+1. Happy path scenarios (P0)
+2. Error handling and edge cases (P1)
+3. User interaction flows (P1)
+4. Boundary conditions (P2)
+
+Return ONLY valid JSON array, no markdown fences, no explanation.`;
+}
+
+export function buildGenerationPrompt(testCases, context) {
+  return `You are a senior test engineer writing test code.
+
+## Context
+- Framework: ${context.framework || "react"}
+- Test Runner: ${context.runner || "jest"}
+- Language: JavaScript/JSX
+- Libraries: @testing-library/react, @testing-library/user-event, redux-mock-store
+
+## Test Cases to Implement
+${JSON.stringify(testCases, null, 2)}
+
+## Rules
+1. Use @testing-library/react for rendering
+2. Use @testing-library/user-event for interactions
+3. Use screen queries (getByRole, getByText, getByTestId)
+4. Use waitFor for async assertions
+5. Each test must be independent
+6. Use descriptive test names
+7. Handle async operations properly
+
+Write complete, runnable test code. Return ONLY the code, no explanation.`;
+}
+
+export function buildRecommendationPrompt(results) {
+  const summary = results.summary || {};
+  const failedTests = (results.results || [])
+    .flatMap((r) => r.tests || [])
+    .filter((t) => t.status === "failed")
+    .slice(0, 5);
+
+  return `You are a QA lead reviewing test results.
+
+## Summary
+- Total: ${summary.totalTests}, Passed: ${summary.totalPassed}, Failed: ${summary.totalFailed}
+- Pass Rate: ${summary.overallPassRate}%
+
+## Failed Tests
+${failedTests.map((t) => `- ${t.name}: ${t.error?.message || "unknown error"}`).join("\n")}
+
+Provide 3-5 actionable recommendations to improve test quality. Return as JSON array:
+[{"priority": "high|medium|low", "recommendation": "...", "rationale": "..."}]
+
+Return ONLY valid JSON array.`;
+}
+
+function truncate(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return str.slice(0, maxLen) + "\n... (truncated)";
+}

package/src/ai/usecase-parser.js

@@ -0,0 +1,124 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+
+export class UseCaseParser {
+  async parse(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const content = await readFile(filePath, "utf-8");
+
+    switch (ext) {
+      case ".md":
+        return this.parseMarkdown(content);
+      case ".feature":
+        return this.parseGherkin(content);
+      default:
+        return this.parsePlainText(content);
+    }
+  }
+
+  parseMarkdown(content) {
+    const scenarios = [];
+    const sections = content.split(/^##\s+/m).filter(Boolean);
+
+    for (const section of sections) {
+      const lines = section.split("\n");
+      const title = lines[0]?.trim();
+      if (!title) continue;
+
+      const titleIsStep =
+        /^\s*\d+\.\s+/.test(title) || /^\s*[-*]\s+/.test(title);
+      if (titleIsStep) continue;
+
+      const steps = lines
+        .slice(1)
+        .filter((l) => /^\s*\d+\.\s+/.test(l) || /^\s*[-*]\s+/.test(l))
+        .map((l) =>
+          l
+            .replace(/^\s*\d+\.\s+/, "")
+            .replace(/^\s*[-*]\s+/, "")
+            .trim(),
+        )
+        .filter(Boolean);
+
+      if (steps.length > 0) {
+        scenarios.push({ scenario: title, steps, source: "markdown" });
+      }
+    }
+
+    if (scenarios.length === 0) {
+      const allSteps = content
+        .split("\n")
+        .filter((l) => /^\s*\d+\.\s+/.test(l) || /^\s*[-*]\s+/.test(l))
+        .map((l) =>
+          l
+            .replace(/^\s*\d+\.\s+/, "")
+            .replace(/^\s*[-*]\s+/, "")
+            .trim(),
+        )
+        .filter(Boolean);
+
+      if (allSteps.length > 0) {
+        scenarios.push({
+          scenario: "Default Flow",
+          steps: allSteps,
+          source: "markdown",
+        });
+      }
+    }
+
+    return scenarios;
+  }
+
+  parseGherkin(content) {
+    const scenarios = [];
+    const scenarioBlocks = content
+      .split(/^(?:Scenario|Scenario Outline):\s*/m)
+      .slice(1);
+
+    for (const block of scenarioBlocks) {
+      const lines = block.split("\n");
+      const title = lines[0]?.trim();
+      const steps = lines
+        .slice(1)
+        .filter((l) => /^\s*(Given|When|Then|And|But)\s+/i.test(l))
+        .map((l) => l.trim())
+        .filter(Boolean);
+
+      if (title && steps.length > 0) {
+        scenarios.push({ scenario: title, steps, source: "gherkin" });
+      }
+    }
+
+    return scenarios;
+  }
+
+  parsePlainText(content) {
+    const scenarios = [];
+    const blocks = content.split(/\n\s*\n/).filter(Boolean);
+
+    for (const block of blocks) {
+      const lines = block
+        .split("\n")
+        .map((l) => l.trim())
+        .filter(Boolean);
+      if (lines.length < 2) continue;
+
+      const hasNumbers = lines.some((l) => /^\d+[.)]\s+/.test(l));
+      if (hasNumbers) {
+        const steps = lines
+          .filter((l) => /^\d+[.)]\s+/.test(l))
+          .map((l) => l.replace(/^\d+[.)]\s+/, "").trim());
+        const title = lines.find((l) => !/^\d+[.)]\s+/.test(l)) || "Flow";
+        scenarios.push({ scenario: title, steps, source: "text" });
+      } else if (lines.length >= 2) {
+        scenarios.push({
+          scenario: lines[0],
+          steps: lines.slice(1),
+          source: "text",
+        });
+      }
+    }
+
+    return scenarios;
+  }
+}

package/src/analyzers/env-detector.js

@@ -0,0 +1,110 @@
+import path from "node:path";
+import { readdir } from "node:fs/promises";
+import { safeReadFile, fileExists } from "../utils/file-utils.js";
+
+export async function detectEnvironments(projectDir) {
+  const result = { environments: {}, envFiles: [], variables: {} };
+
+  result.envFiles = await findEnvFiles(projectDir);
+
+  for (const envFile of result.envFiles) {
+    const parsed = await parseEnvFile(path.join(projectDir, envFile));
+    const envName = envNameFromFile(envFile);
+
+    const urlVars = Object.entries(parsed).filter(
+      ([k, v]) =>
+        (k.includes("URL") ||
+          k.includes("HOST") ||
+          k.includes("BASE") ||
+          k.includes("API")) &&
+        (v.startsWith("http://") || v.startsWith("https://")),
+    );
+
+    if (urlVars.length > 0) {
+      const [, url] = urlVars[0];
+      result.environments[envName] = { url, source: envFile };
+    }
+
+    Object.assign(result.variables, parsed);
+  }
+
+  if (Object.keys(result.environments).length === 0) {
+    const webpackEnvs = await detectWebpackEnvironments(projectDir);
+    Object.assign(result.environments, webpackEnvs);
+  }
+
+  return result;
+}
+
+async function findEnvFiles(dir) {
+  try {
+    const entries = await readdir(dir);
+    return entries
+      .filter((e) => e.startsWith(".env") && !e.includes("example"))
+      .sort();
+  } catch {
+    return [];
+  }
+}
+
+async function parseEnvFile(filePath) {
+  const content = await safeReadFile(filePath);
+  if (!content) return {};
+
+  const vars = {};
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIdx = trimmed.indexOf("=");
+    if (eqIdx === -1) continue;
+    const key = trimmed.slice(0, eqIdx).trim();
+    const value = trimmed
+      .slice(eqIdx + 1)
+      .trim()
+      .replace(/^["']|["']$/g, "");
+    vars[key] = value;
+  }
+  return vars;
+}
+
+function envNameFromFile(filename) {
+  if (filename === ".env") return "default";
+  const suffix = filename.replace(/^\.env\.?/, "");
+  return suffix || "default";
+}
+
+async function detectWebpackEnvironments(dir) {
+  const envs = {};
+  try {
+    const entries = await readdir(dir);
+    const webpackConfigs = entries.filter(
+      (e) =>
+        e.startsWith("webpack.") &&
+        e.endsWith(".js") &&
+        e !== "webpack.base.babel.js",
+    );
+
+    for (const config of webpackConfigs) {
+      const envName = config
+        .replace("webpack.", "")
+        .replace(".babel.js", "")
+        .replace(".js", "");
+      if (envName === "base" || envName === "common") continue;
+
+      const content = await safeReadFile(path.join(dir, config));
+      if (!content) continue;
+
+      const urlMatch = content.match(
+        /(?:BASE_URL|API_URL|SITE_URL|PUBLIC_URL)\s*[:=]\s*["'`](https?:\/\/[^"'`]+)["'`]/,
+      );
+      if (urlMatch) {
+        envs[envName] = { url: urlMatch[1], source: config };
+      } else {
+        envs[envName] = { url: null, source: config };
+      }
+    }
+  } catch {
+    /* ignore */
+  }
+  return envs;
+}