@nhonh/qabot 0.4.1 → 0.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nhonh/qabot",
-  "version": "0.4.1",
+  "version": "0.5.1",
   "description": "AI-powered universal QA automation tool. Import any project, AI analyzes and runs tests across all layers.",
   "main": "src/index.js",
   "bin": {

package/src/ai/ai-engine.js

@@ -2,6 +2,7 @@ import {
   buildAnalysisPrompt,
   buildGenerationPrompt,
   buildRecommendationPrompt,
+  buildFixPrompt,
 } from "./prompt-builder.js";
 import { AI_PROVIDER_DEFAULTS } from "../core/constants.js";
 
@@ -93,9 +94,13 @@ export class AIEngine {
         if (!isFirst) {
           batchContext.existingTestCode = "";
           batchContext.sourceCode = "";
+          batchContext.isContinuation = true;
         }
         const prompt = buildGenerationPrompt(batches[i], batchContext);
-        const code = await this.complete(prompt);
+        let code = await this.complete(prompt);
+        if (!isFirst) {
+          code = stripDuplicateImports(code);
+        }
         fullCode += (isFirst ? "" : "\n\n") + code;
       }
     } finally {
@@ -105,6 +110,17 @@ export class AIEngine {
     return fullCode;
   }
 
+  async fixTestCode(code, errorMessage, context) {
+    const prompt = buildFixPrompt(code, errorMessage, context);
+    const savedMaxTokens = this.maxTokens;
+    this.maxTokens = Math.max(this.maxTokens, 8192);
+    try {
+      return await this.complete(prompt);
+    } finally {
+      this.maxTokens = savedMaxTokens;
+    }
+  }
+
   async generateRecommendations(results) {
     const prompt = buildRecommendationPrompt(results);
     return this.complete(prompt);
@@ -286,6 +302,36 @@ export class AIEngine {
   }
 }
 
+function stripDuplicateImports(code) {
+  const lines = code.split("\n");
+  let inMockBlock = false;
+  let braceDepth = 0;
+  const filtered = [];
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    if (trimmed.startsWith("import ")) continue;
+    if (trimmed.startsWith("jest.mock(")) {
+      inMockBlock = true;
+      braceDepth = 0;
+    }
+
+    if (inMockBlock) {
+      braceDepth += (line.match(/\{/g) || []).length;
+      braceDepth -= (line.match(/\}/g) || []).length;
+      if (braceDepth <= 0 && trimmed.endsWith(");")) {
+        inMockBlock = false;
+      }
+      continue;
+    }
+
+    filtered.push(line);
+  }
+
+  return filtered.join("\n").trim();
+}
+
 function resolveApiKey(config) {
   if (config.apiKey) return config.apiKey;
   if (config.apiKeyEnv) return process.env[config.apiKeyEnv] || "";

package/src/ai/prompt-builder.js

@@ -44,6 +44,11 @@ export function buildGenerationPrompt(testCases, context) {
     : "";
 
   const importPath = context.importPath || "../index";
+  const isContinuation = context.isContinuation || false;
+
+  const continuationRule = isContinuation
+    ? `\nIMPORTANT: This is a CONTINUATION batch. Do NOT include any import statements, require() calls, or jest.mock() calls. Write ONLY describe() and it() blocks. The imports and mocks are already defined in a previous batch.\n`
+    : "";
 
   return `You are a senior test engineer writing production-quality test code.
 
@@ -52,16 +57,15 @@ export function buildGenerationPrompt(testCases, context) {
 - Test Runner: ${context.runner || "jest"}
 - Language: JavaScript/JSX
 - Import path for module under test: "${importPath}"
-${sourceSection}${existingTestSection}
+${sourceSection}${existingTestSection}${continuationRule}
 ## Test Cases to Implement
 ${JSON.stringify(testCases, null, 2)}
 
 ## Rules
-1. Write a COMPLETE, RUNNABLE test file with all imports
+1. ${isContinuation ? "Write ONLY describe/it blocks — NO imports, NO jest.mock" : "Write a COMPLETE, RUNNABLE test file with all imports"}
 2. Use @testing-library/react for rendering components
 3. Use @testing-library/user-event for user interactions
-4. Use jest.mock() for module mocking
-5. Use screen queries: getByRole, getByText, getByTestId
+${isContinuation ? "" : "4. Use jest.mock() for module mocking\n"}5. Use screen queries: getByRole, getByText, getByTestId
 6. Use waitFor and findBy* for async assertions
 7. Each test must be independent — no shared mutable state
 8. Use descriptive it() names matching the test case names above
@@ -94,6 +98,41 @@ Provide 3-5 actionable recommendations to improve test quality. Return as JSON a
 Return ONLY valid JSON array.`;
 }
 
+export function buildFixPrompt(code, errorMessage, context) {
+  return `You are a senior test engineer fixing a broken test file.
+
+## Error from test runner
+\`\`\`
+${truncate(errorMessage, 2000)}
+\`\`\`
+
+## Current test file (has errors)
+\`\`\`javascript
+${truncate(code, 10000)}
+\`\`\`
+
+## Project Context
+- Framework: ${context.framework || "react"}
+- Test Runner: ${context.runner || "jest"}
+- Module aliases: ~/ maps to src/
+- Tests are in: src/<feature>/tests/<Name>.test.js
+
+## Common fixes needed
+1. Duplicate imports — remove duplicate import/require lines
+2. Wrong import paths — use ~/ alias for src/ imports
+3. Missing mock — add jest.mock() for unmocked dependencies
+4. Syntax errors — fix unclosed brackets, parens, template literals
+5. Wrong API usage — check if mocked functions match actual API
+
+## Rules
+- Return the COMPLETE fixed test file
+- Do NOT remove any test cases — fix them
+- Do NOT add markdown fences
+- Return ONLY the JavaScript code
+
+Fix ALL errors and return the complete corrected file.`;
+}
+
 function truncate(str, maxLen) {
   if (str.length <= maxLen) return str;
   return str.slice(0, maxLen) + "\n... (truncated)";

package/src/cli/commands/generate.js

@@ -1,7 +1,8 @@
 import chalk from "chalk";
 import ora from "ora";
 import path from "node:path";
-import { writeFile } from "node:fs/promises";
+import { writeFile, readFile } from "node:fs/promises";
+import { execSync } from "node:child_process";
 import Enquirer from "enquirer";
 import { logger } from "../../core/logger.js";
 import { loadConfig } from "../../core/config.js";
@@ -10,6 +11,8 @@ import { AIEngine } from "../../ai/ai-engine.js";
 import { UseCaseParser } from "../../ai/usecase-parser.js";
 import { findFiles, safeReadFile, ensureDir } from "../../utils/file-utils.js";
 
+const MAX_FIX_ATTEMPTS = 3;
+
 export function registerGenerateCommand(program) {
   program
     .command("generate [feature]")
@@ -17,6 +20,7 @@ export function registerGenerateCommand(program) {
     .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("--no-fix", "Skip auto-fix loop")
     .option("--model <model>", "AI model to use")
     .option("-d, --dir <path>", "Project directory", process.cwd())
     .action(runGenerate);
@@ -39,7 +43,7 @@ async function runGenerate(feature, options) {
     logger.error("AI is not configured.");
     logger.blank();
     logger.info("Quick setup:");
-    logger.dim("  qabot auth                    # Interactive provider setup");
+    logger.dim("  qabot auth");
     logger.blank();
     logger.info(
       "Supported: openai, anthropic, gemini, deepseek, groq, ollama, proxy",
@@ -53,12 +57,12 @@ async function runGenerate(feature, options) {
   const featureConfig = config.features?.[feature];
   if (!featureConfig) {
     logger.error(
-      `Feature "${feature}" not found in config. Run \`qabot list features\` to see available.`,
+      `Feature "${feature}" not found. Run \`qabot list features\`.`,
     );
     return;
   }
 
-  const spinner = ora("Reading feature source code...").start();
+  const spinner = ora("Reading source code...").start();
 
   const sourceFiles = await findFiles(
     projectDir,
@@ -80,24 +84,14 @@ async function runGenerate(feature, options) {
     return;
   }
 
-  spinner.text = `Found ${sourceFilesFiltered.length} source files. Reading existing tests...`;
-
   const existingTestFiles = await findFiles(
     projectDir,
-    `${featureConfig.src}/**/tests/*.test.{js,jsx,ts,tsx}`,
+    "src/**/tests/*.test.{js,jsx,ts,tsx}",
   );
-  let existingTestCode = "";
-  if (existingTestFiles.length > 0) {
-    existingTestCode = (await safeReadFile(existingTestFiles[0])) || "";
-  } else {
-    const anyTestFiles = await findFiles(
-      projectDir,
-      "src/**/tests/*.test.{js,jsx,ts,tsx}",
-    );
-    if (anyTestFiles.length > 0) {
-      existingTestCode = (await safeReadFile(anyTestFiles[0])) || "";
-    }
-  }
+  const existingTestCode =
+    existingTestFiles.length > 0
+      ? (await safeReadFile(existingTestFiles[0])) || ""
+      : "";
 
   let useCases = [];
   const useCaseDir = options.useCases || config.useCases?.dir;
@@ -109,18 +103,17 @@ async function runGenerate(feature, options) {
     );
     for (const f of ucFiles) {
       try {
-        const parsed = await parser.parse(f);
-        useCases.push(...parsed);
+        useCases.push(...(await parser.parse(f)));
       } catch {
-        /* skip unparseable */
+        /* skip */
       }
     }
   }
 
-  spinner.text = "AI is analyzing code and generating test plan...";
-
   const runner = config.layers?.[options.layer || "unit"]?.runner || "jest";
 
+  spinner.text = "AI is generating test plan...";
+
   let testPlan;
   try {
     testPlan = await ai.analyzeCode(sourceCode, {
@@ -161,7 +154,6 @@ async function runGenerate(feature, options) {
   }
 
   logger.blank();
-
   const enquirer = new Enquirer();
   const { proceed } = await enquirer.prompt({
     type: "confirm",
@@ -169,73 +161,147 @@ async function runGenerate(feature, options) {
     message: `Generate test code for ${testPlan.length} test cases?`,
     initial: true,
   });
-
   if (!proceed) {
     logger.warn("Cancelled.");
     return;
   }
 
+  const testsDir = path.join(projectDir, featureConfig.src, "tests");
+  await ensureDir(testsDir);
+  const testFileName = `${toPascalCase(feature)}.generated.test.js`;
+  const testFilePath = path.join(testsDir, testFileName);
+  const relativePath = path.relative(projectDir, testFilePath);
+
   const spinner2 = ora("AI is writing test code...").start();
 
+  let code;
   try {
-    const code = await ai.generateTestCode(testPlan, {
+    code = await ai.generateTestCode(testPlan, {
       framework: profile.techStack.framework,
       runner,
       sourceCode,
       existingTestCode,
       importPath: `./${path.basename(featureConfig.src)}`,
     });
+  } catch (err) {
+    spinner2.fail("Code generation failed");
+    logger.error(err.message);
+    return;
+  }
 
-    spinner2.succeed("Test code generated");
-
-    const cleanCode = cleanGeneratedCode(code);
+  code = cleanGeneratedCode(code);
+  await writeFile(testFilePath, code, "utf-8");
+  spinner2.succeed(`Test file written: ${chalk.underline(relativePath)}`);
 
-    const testsDir = path.join(projectDir, featureConfig.src, "tests");
-    await ensureDir(testsDir);
+  if (options.fix === false) {
+    logger.blank();
+    logger.info("Skipping auto-fix (--no-fix). Run manually:");
+    logger.dim(`  qabot run ${feature}`);
+    return;
+  }
 
-    const testFileName = `${toPascalCase(feature)}.generated.test.js`;
-    const testFilePath = path.join(testsDir, testFileName);
-    await writeFile(testFilePath, cleanCode, "utf-8");
+  logger.blank();
+  logger.info("Running auto-fix loop...");
 
-    const relativePath = path.relative(projectDir, testFilePath);
+  const testCommand = config.layers?.unit?.command || "npx jest";
 
+  for (let attempt = 1; attempt <= MAX_FIX_ATTEMPTS; attempt++) {
     logger.blank();
-    logger.success(`Test file written: ${chalk.underline(relativePath)}`);
-    logger.blank();
-    logger.info("Next steps:");
-    logger.dim(`  qabot run ${feature}              # Run the generated tests`);
-    logger.dim(`  cat ${relativePath}    # Review generated code`);
-    logger.dim(`  qabot generate ${feature} --dry-run  # Regenerate plan only`);
-    logger.blank();
+    logger.step(
+      attempt,
+      MAX_FIX_ATTEMPTS,
+      `Attempt ${attempt}: running tests...`,
+    );
+
+    const { exitCode, error: testError } = runJestQuiet(
+      projectDir,
+      testFilePath,
+      testCommand,
+    );
+
+    if (exitCode === 0) {
+      logger.blank();
+      logger.success(`Tests pass on attempt ${attempt}!`);
+      logger.blank();
+      logger.info("Run tests:");
+      logger.dim(`  qabot run ${feature}`);
+      return;
+    }
+
+    if (attempt >= MAX_FIX_ATTEMPTS) {
+      logger.blank();
+      logger.warn(`Tests still failing after ${MAX_FIX_ATTEMPTS} attempts.`);
+      logger.dim("  Review and fix manually:");
+      logger.dim(`  cat ${relativePath}`);
+      logger.dim(`  qabot run ${feature} --verbose`);
+      return;
+    }
+
+    logger.dim(`  Error: ${testError.split("\\n")[0].slice(0, 120)}`);
+    logger.step(attempt, MAX_FIX_ATTEMPTS, "AI is fixing errors...");
+
+    const currentCode = await readFile(testFilePath, "utf-8");
+    try {
+      let fixedCode = await ai.fixTestCode(currentCode, testError, {
+        framework: profile.techStack.framework,
+        runner,
+      });
+      fixedCode = cleanGeneratedCode(fixedCode);
+      await writeFile(testFilePath, fixedCode, "utf-8");
+      logger.dim("  Fix applied. Re-running...");
+    } catch (err) {
+      logger.warn(`  AI fix failed: ${err.message}`);
+      break;
+    }
+  }
+}
+
+function runJestQuiet(projectDir, testFilePath, testCommand) {
+  const relativePath = path.relative(projectDir, testFilePath);
+  let cmd;
+  if (testCommand.startsWith("npm")) {
+    cmd = `${testCommand} -- --testPathPattern="${relativePath}" --no-coverage --forceExit`;
+  } else {
+    cmd = `npx jest --testPathPattern="${relativePath}" --no-coverage --forceExit`;
+  }
+
+  try {
+    execSync(cmd, {
+      cwd: projectDir,
+      stdio: "pipe",
+      timeout: 60000,
+      env: { ...process.env, FORCE_COLOR: "0" },
+    });
+    return { exitCode: 0, error: "" };
   } catch (err) {
-    spinner2.fail("Test code generation failed");
-    logger.error(err.message);
+    const stderr = err.stderr?.toString() || "";
+    const stdout = err.stdout?.toString() || "";
+    return {
+      exitCode: err.status || 1,
+      error: (stderr || stdout).slice(0, 3000),
+    };
   }
 }
 
 function cleanGeneratedCode(code) {
   let cleaned = code.trim();
   if (cleaned.startsWith("```")) {
-    const firstNewline = cleaned.indexOf("\n");
-    cleaned = cleaned.slice(firstNewline + 1);
+    cleaned = cleaned.slice(cleaned.indexOf("\n") + 1);
   }
   if (cleaned.endsWith("```")) {
     cleaned = cleaned.slice(0, cleaned.lastIndexOf("```"));
   }
   cleaned = cleaned.trim();
 
-  const openBraces = (cleaned.match(/\{/g) || []).length;
-  const closeBraces = (cleaned.match(/\}/g) || []).length;
+  const opens = (cleaned.match(/\{/g) || []).length;
+  const closes = (cleaned.match(/\}/g) || []).length;
   const openParens = (cleaned.match(/\(/g) || []).length;
   const closeParens = (cleaned.match(/\)/g) || []).length;
 
   let suffix = "";
   for (let i = 0; i < openParens - closeParens; i++) suffix += ")";
-  for (let i = 0; i < openBraces - closeBraces; i++) suffix += "\n}";
-
-  if (suffix) {
-    cleaned += suffix + ";\n";
-  }
+  for (let i = 0; i < opens - closes; i++) suffix += "\n}";
+  if (suffix) cleaned += suffix + ";\n";
 
   return cleaned + "\n";
 }

package/src/core/constants.js

@@ -1,4 +1,4 @@
-export const VERSION = "0.4.1";
+export const VERSION = "0.5.1";
 export const TOOL_NAME = "qabot";
 
 export const PROJECT_TYPES = [

package/src/runners/jest-runner.js

@@ -1,8 +1,9 @@
 import path from "node:path";
+import { readFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { nanoid } from "nanoid";
 import { BaseRunner } from "./base-runner.js";
-import { fileExists, readJSON } from "../utils/file-utils.js";
+import { fileExists } from "../utils/file-utils.js";
 
 export class JestRunner extends BaseRunner {
   constructor(config) {
@@ -47,12 +48,10 @@ export class JestRunner extends BaseRunner {
 
     try {
       if (this._jsonFile) {
-        jsonData = JSON.parse(
-          require("node:fs").readFileSync(this._jsonFile, "utf-8"),
-        );
+        jsonData = JSON.parse(readFileSync(this._jsonFile, "utf-8"));
       }
     } catch {
-      /* fallback to stdout parsing */
+      /* JSON file not found — parse from stdout */
     }
 
     if (!jsonData) {
@@ -60,22 +59,38 @@ export class JestRunner extends BaseRunner {
         const jsonStart = stdout.indexOf("{");
         if (jsonStart !== -1) jsonData = JSON.parse(stdout.slice(jsonStart));
       } catch {
-        /* parse manually */
+        /* not valid JSON in stdout */
       }
     }
 
     if (jsonData && jsonData.testResults) {
       for (const suite of jsonData.testResults) {
-        for (const test of suite.assertionResults || []) {
+        if (suite.assertionResults?.length > 0) {
+          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,
+            });
+          }
+        } else if (suite.message) {
           tests.push({
-            name: test.fullName || test.title,
-            suite: test.ancestorTitles?.join(" > ") || "",
+            name: `Suite failed: ${path.basename(suite.testFilePath || "unknown")}`,
+            suite: "Test Suite Error",
             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,
+            status: "failed",
+            duration: 0,
+            error: {
+              message: extractErrorSummary(suite.message),
+              stack: suite.message,
+            },
             screenshots: [],
             retries: 0,
           });
@@ -83,21 +98,23 @@ export class JestRunner extends BaseRunner {
       }
     }
 
-    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;
+    if (tests.length === 0 && exitCode !== 0) {
+      const errorMsg = extractErrorFromOutput(stderr || stdout);
+      if (errorMsg) {
+        tests.push({
+          name: "Test execution failed",
+          suite: "Runtime Error",
+          file: "",
+          status: "failed",
+          duration: 0,
+          error: { message: errorMsg, stack: "" },
+          screenshots: [],
+          retries: 0,
+        });
+      }
+    }
 
+    const summary = buildSummary(jsonData, tests, stdout);
     return { tests, summary, coverage: jsonData?.coverageMap || null };
   }
 }
@@ -112,6 +129,34 @@ function mapJestStatus(status) {
   return map[status] || "skipped";
 }
 
+function buildSummary(jsonData, tests, stdout) {
+  let summary;
+
+  if (jsonData) {
+    const suiteFails = jsonData.numFailedTestSuites || 0;
+    const testFails = jsonData.numFailedTests || 0;
+    summary = {
+      total: (jsonData.numTotalTests || 0) + suiteFails,
+      passed: jsonData.numPassedTests || 0,
+      failed: testFails + suiteFails,
+      skipped: (jsonData.numPendingTests || 0) + (jsonData.numTodoTests || 0),
+    };
+  } else {
+    summary = parseSummaryFromStdout(stdout);
+  }
+
+  if (summary.total === 0 && tests.length > 0) {
+    summary.total = tests.length;
+    summary.passed = tests.filter((t) => t.status === "passed").length;
+    summary.failed = tests.filter((t) => t.status === "failed").length;
+    summary.skipped = tests.filter((t) => t.status === "skipped").length;
+  }
+
+  summary.passRate =
+    summary.total > 0 ? Math.round((summary.passed / summary.total) * 100) : 0;
+  return summary;
+}
+
 function parseSummaryFromStdout(stdout) {
   const summary = { total: 0, passed: 0, failed: 0, skipped: 0, passRate: 0 };
   const testMatch = stdout.match(
@@ -125,3 +170,28 @@ function parseSummaryFromStdout(stdout) {
   }
   return summary;
 }
+
+function extractErrorSummary(message) {
+  const lines = message.split("\n").filter((l) => l.trim());
+  const syntaxLine = lines.find(
+    (l) =>
+      l.includes("SyntaxError") ||
+      l.includes("Cannot find") ||
+      l.includes("unexpected token"),
+  );
+  if (syntaxLine) return syntaxLine.trim().slice(0, 200);
+  return lines[0]?.trim().slice(0, 200) || "Unknown error";
+}
+
+function extractErrorFromOutput(output) {
+  if (!output) return null;
+  const lines = output.split("\n");
+  const errorLine = lines.find(
+    (l) =>
+      l.includes("SyntaxError") ||
+      l.includes("Error:") ||
+      l.includes("Cannot find") ||
+      l.includes("FAIL"),
+  );
+  return errorLine?.trim().slice(0, 300) || null;
+}