@nhonh/qabot 0.3.2 → 0.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nhonh/qabot",
-  "version": "0.3.2",
+  "version": "0.4.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

@@ -64,8 +64,45 @@ export class AIEngine {
   }
 
   async generateTestCode(testCases, context) {
-    const prompt = buildGenerationPrompt(testCases, context);
-    return this.complete(prompt);
+    const maxBatchSize = 8;
+
+    if (testCases.length <= maxBatchSize) {
+      const prompt = buildGenerationPrompt(testCases, context);
+      const savedMaxTokens = this.maxTokens;
+      this.maxTokens = Math.max(this.maxTokens, 8192);
+      try {
+        return await this.complete(prompt);
+      } finally {
+        this.maxTokens = savedMaxTokens;
+      }
+    }
+
+    const batches = [];
+    for (let i = 0; i < testCases.length; i += maxBatchSize) {
+      batches.push(testCases.slice(i, i + maxBatchSize));
+    }
+
+    const savedMaxTokens = this.maxTokens;
+    this.maxTokens = Math.max(this.maxTokens, 8192);
+
+    let fullCode = "";
+    try {
+      for (let i = 0; i < batches.length; i++) {
+        const isFirst = i === 0;
+        const batchContext = { ...context };
+        if (!isFirst) {
+          batchContext.existingTestCode = "";
+          batchContext.sourceCode = "";
+        }
+        const prompt = buildGenerationPrompt(batches[i], batchContext);
+        const code = await this.complete(prompt);
+        fullCode += (isFirst ? "" : "\n\n") + code;
+      }
+    } finally {
+      this.maxTokens = savedMaxTokens;
+    }
+
+    return fullCode;
   }
 
   async generateRecommendations(results) {

package/src/ai/prompt-builder.js

@@ -35,27 +35,41 @@ 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.
+  const sourceSection = context.sourceCode
+    ? `\n## Source Code Being Tested\n\`\`\`\n${truncate(context.sourceCode, 6000)}\n\`\`\`\n`
+    : "";
+
+  const existingTestSection = context.existingTestCode
+    ? `\n## Existing Test Examples (match this style exactly)\n\`\`\`\n${truncate(context.existingTestCode, 3000)}\n\`\`\`\n`
+    : "";
+
+  const importPath = context.importPath || "../index";
+
+  return `You are a senior test engineer writing production-quality 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
-
+- Import path for module under test: "${importPath}"
+${sourceSection}${existingTestSection}
 ## 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.`;
+1. 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
+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
+9. Group related tests in describe() blocks
+10. Mock external dependencies (API calls, Redux store, Router)
+11. Do NOT import from node_modules paths — use package names
+
+Return ONLY the JavaScript code. No markdown fences. No explanation before or after the code.`;
 }
 
 export function buildRecommendationPrompt(results) {

package/src/cli/commands/generate.js

@@ -1,11 +1,14 @@
 import chalk from "chalk";
 import ora from "ora";
+import path from "node:path";
+import { writeFile } from "node:fs/promises";
+import Enquirer from "enquirer";
 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";
+import { findFiles, safeReadFile, ensureDir } from "../../utils/file-utils.js";
 
 export function registerGenerateCommand(program) {
   program
@@ -38,11 +41,6 @@ async function runGenerate(feature, options) {
     logger.info("Quick setup:");
     logger.dim("  qabot auth                    # Interactive provider setup");
     logger.blank();
-    logger.info("Or set manually:");
-    logger.dim(
-      "  export OPENAI_API_KEY=sk-...  # Then set ai.provider in qabot.config.js",
-    );
-    logger.blank();
     logger.info(
       "Supported: openai, anthropic, gemini, deepseek, groq, ollama, proxy",
     );
@@ -52,26 +50,55 @@ async function runGenerate(feature, options) {
   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(
+    logger.error(
       `Feature "${feature}" not found in config. Run \`qabot list features\` to see available.`,
     );
     return;
   }
 
+  const spinner = ora("Reading feature source code...").start();
+
   const sourceFiles = await findFiles(
     projectDir,
     `${featureConfig.src}/**/*.{js,jsx,ts,tsx}`,
   );
+  const sourceFilesFiltered = sourceFiles.filter(
+    (f) => !f.includes("/tests/") && !f.includes(".test."),
+  );
   const sourceCode = (
-    await Promise.all(sourceFiles.slice(0, 10).map((f) => safeReadFile(f)))
+    await Promise.all(
+      sourceFilesFiltered.slice(0, 10).map((f) => safeReadFile(f)),
+    )
   )
     .filter(Boolean)
     .join("\n\n---\n\n");
 
+  if (!sourceCode.trim()) {
+    spinner.fail(`No source files found at ${featureConfig.src}`);
+    return;
+  }
+
+  spinner.text = `Found ${sourceFilesFiltered.length} source files. Reading existing tests...`;
+
+  const existingTestFiles = await findFiles(
+    projectDir,
+    `${featureConfig.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])) || "";
+    }
+  }
+
   let useCases = [];
   const useCaseDir = options.useCases || config.useCases?.dir;
   if (useCaseDir) {
@@ -81,55 +108,141 @@ async function runGenerate(feature, options) {
       `${useCaseDir}/**/*.{md,feature,txt}`,
     );
     for (const f of ucFiles) {
-      const parsed = await parser.parse(f);
-      useCases.push(...parsed);
+      try {
+        const parsed = await parser.parse(f);
+        useCases.push(...parsed);
+      } catch {
+        /* skip unparseable */
+      }
     }
   }
 
   spinner.text = "AI is analyzing code and generating test plan...";
 
+  const runner = config.layers?.[options.layer || "unit"]?.runner || "jest";
+
+  let testPlan;
   try {
-    const testPlan = await ai.analyzeCode(sourceCode, {
+    testPlan = await ai.analyzeCode(sourceCode, {
       framework: profile.techStack.framework,
-      runner: config.layers?.[options.layer || "unit"]?.runner || "jest",
-      existingTestCount: 0,
+      runner,
+      existingTestCount: existingTestFiles.length,
       useCases,
     });
+  } catch (err) {
+    spinner.fail("AI analysis failed");
+    logger.error(err.message);
+    return;
+  }
 
-    spinner.succeed("Test plan generated");
+  if (!Array.isArray(testPlan) || testPlan.length === 0) {
+    spinner.fail("AI returned no test cases");
+    return;
+  }
+
+  spinner.succeed(`Generated ${testPlan.length} test cases`);
+  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(`      Type: ${tc.type} | Priority: ${tc.priority}`);
+  }
+
+  if (options.dryRun) {
     logger.blank();
+    logger.info("Dry run complete. No files written.");
+    return;
+  }
 
-    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}`);
-      }
-    }
+  logger.blank();
 
-    if (options.dryRun) {
-      logger.blank();
-      logger.info("Dry run complete. No files written.");
-      return;
-    }
+  const enquirer = new Enquirer();
+  const { proceed } = await enquirer.prompt({
+    type: "confirm",
+    name: "proceed",
+    message: `Generate test code for ${testPlan.length} test cases?`,
+    initial: true,
+  });
+
+  if (!proceed) {
+    logger.warn("Cancelled.");
+    return;
+  }
+
+  const spinner2 = ora("AI is writing test code...").start();
+
+  try {
+    const code = await ai.generateTestCode(testPlan, {
+      framework: profile.techStack.framework,
+      runner,
+      sourceCode,
+      existingTestCode,
+      importPath: `./${path.basename(featureConfig.src)}`,
+    });
+
+    spinner2.succeed("Test code generated");
+
+    const cleanCode = cleanGeneratedCode(code);
+
+    const testsDir = path.join(projectDir, featureConfig.src, "tests");
+    await ensureDir(testsDir);
+
+    const testFileName = `${toPascalCase(feature)}.generated.test.js`;
+    const testFilePath = path.join(testsDir, testFileName);
+    await writeFile(testFilePath, cleanCode, "utf-8");
+
+    const relativePath = path.relative(projectDir, testFilePath);
 
     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.",
-    );
+    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();
   } catch (err) {
-    spinner.fail("AI analysis failed");
+    spinner2.fail("Test code generation failed");
     logger.error(err.message);
   }
 }
+
+function cleanGeneratedCode(code) {
+  let cleaned = code.trim();
+  if (cleaned.startsWith("```")) {
+    const firstNewline = cleaned.indexOf("\n");
+    cleaned = cleaned.slice(firstNewline + 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 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";
+  }
+
+  return cleaned + "\n";
+}
+
+function toPascalCase(str) {
+  return str
+    .split(/[-_\s]+/)
+    .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
+    .join("");
+}

package/src/core/constants.js

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