@amit641/testpilot-ai 0.1.0

package/dist/index.js

@@ -0,0 +1,1056 @@
+import * as ts from 'typescript';
+import { readFileSync, existsSync, writeFileSync, mkdirSync } from 'fs';
+import { extname, basename, dirname, resolve, relative, join } from 'path';
+import { ai } from 'aiclientjs';
+import pc from 'picocolors';
+import { execSync } from 'child_process';
+
+// src/analyzer/index.ts
+function analyzeFile(filePath) {
+  const sourceCode = readFileSync(filePath, "utf-8");
+  const ext = extname(filePath);
+  const language = ext === ".ts" || ext === ".tsx" ? "typescript" : "javascript";
+  const sourceFile = ts.createSourceFile(
+    filePath,
+    sourceCode,
+    ts.ScriptTarget.Latest,
+    true,
+    ext === ".tsx" || ext === ".jsx" ? ts.ScriptKind.TSX : ts.ScriptKind.TS
+  );
+  const exports$1 = [];
+  const imports = [];
+  visitNode(sourceFile, sourceFile, exports$1, imports);
+  const dependencies = imports.filter((i) => !i.isRelative).map((i) => i.source);
+  return {
+    filePath,
+    fileName: basename(filePath),
+    language,
+    sourceCode,
+    exports: exports$1,
+    imports,
+    dependencies
+  };
+}
+function visitNode(node, sourceFile, exports$1, imports) {
+  if (ts.isImportDeclaration(node) && node.moduleSpecifier) {
+    const source = node.moduleSpecifier.text;
+    const specifiers = [];
+    if (node.importClause) {
+      if (node.importClause.name) {
+        specifiers.push(node.importClause.name.text);
+      }
+      if (node.importClause.namedBindings) {
+        if (ts.isNamedImports(node.importClause.namedBindings)) {
+          for (const el of node.importClause.namedBindings.elements) {
+            specifiers.push(el.name.text);
+          }
+        } else if (ts.isNamespaceImport(node.importClause.namedBindings)) {
+          specifiers.push(`* as ${node.importClause.namedBindings.name.text}`);
+        }
+      }
+    }
+    imports.push({
+      source,
+      specifiers,
+      isRelative: source.startsWith(".")
+    });
+  }
+  if (ts.isFunctionDeclaration(node) && hasExportModifier(node)) {
+    const name = node.name?.text ?? "default";
+    exports$1.push({
+      name,
+      kind: "function",
+      signature: getSignatureText(node, sourceFile),
+      jsDoc: getJSDoc(node, sourceFile),
+      isAsync: hasAsyncModifier(node),
+      isDefault: hasDefaultModifier(node),
+      lineNumber: getLineNumber(node, sourceFile),
+      parameters: getParameters(node.parameters, sourceFile),
+      returnType: node.type ? node.type.getText(sourceFile) : void 0
+    });
+  }
+  if (ts.isClassDeclaration(node) && hasExportModifier(node)) {
+    const name = node.name?.text ?? "default";
+    exports$1.push({
+      name,
+      kind: "class",
+      signature: getClassSignature(node, sourceFile),
+      jsDoc: getJSDoc(node, sourceFile),
+      isAsync: false,
+      isDefault: hasDefaultModifier(node),
+      lineNumber: getLineNumber(node, sourceFile)
+    });
+  }
+  if (ts.isVariableStatement(node) && hasExportModifier(node)) {
+    for (const decl of node.declarationList.declarations) {
+      if (!ts.isIdentifier(decl.name)) continue;
+      const name = decl.name.text;
+      const isArrow = decl.initializer && ts.isArrowFunction(decl.initializer);
+      const isFuncExpr = decl.initializer && ts.isFunctionExpression(decl.initializer);
+      if (isArrow || isFuncExpr) {
+        const func = decl.initializer;
+        exports$1.push({
+          name,
+          kind: "arrow-function",
+          signature: getSignatureText(node, sourceFile),
+          jsDoc: getJSDoc(node, sourceFile),
+          isAsync: hasAsyncModifier(func),
+          isDefault: false,
+          lineNumber: getLineNumber(node, sourceFile),
+          parameters: getParameters(func.parameters, sourceFile),
+          returnType: func.type ? func.type.getText(sourceFile) : void 0
+        });
+      } else {
+        exports$1.push({
+          name,
+          kind: "variable",
+          signature: decl.getText(sourceFile),
+          jsDoc: getJSDoc(node, sourceFile),
+          isAsync: false,
+          isDefault: false,
+          lineNumber: getLineNumber(node, sourceFile)
+        });
+      }
+    }
+  }
+  if (ts.isInterfaceDeclaration(node) && hasExportModifier(node)) {
+    exports$1.push({
+      name: node.name.text,
+      kind: "interface",
+      signature: node.getText(sourceFile),
+      isAsync: false,
+      isDefault: false,
+      lineNumber: getLineNumber(node, sourceFile)
+    });
+  }
+  if (ts.isTypeAliasDeclaration(node) && hasExportModifier(node)) {
+    exports$1.push({
+      name: node.name.text,
+      kind: "type",
+      signature: node.getText(sourceFile),
+      isAsync: false,
+      isDefault: false,
+      lineNumber: getLineNumber(node, sourceFile)
+    });
+  }
+  if (ts.isEnumDeclaration(node) && hasExportModifier(node)) {
+    exports$1.push({
+      name: node.name.text,
+      kind: "enum",
+      signature: node.getText(sourceFile),
+      isAsync: false,
+      isDefault: false,
+      lineNumber: getLineNumber(node, sourceFile)
+    });
+  }
+  ts.forEachChild(node, (child) => visitNode(child, sourceFile, exports$1, imports));
+}
+function hasExportModifier(node) {
+  const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : void 0;
+  return modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+}
+function hasDefaultModifier(node) {
+  const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : void 0;
+  return modifiers?.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword) ?? false;
+}
+function hasAsyncModifier(node) {
+  const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : void 0;
+  return modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+}
+function getLineNumber(node, sourceFile) {
+  return sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1;
+}
+function getSignatureText(node, sourceFile) {
+  const fullText = node.getText(sourceFile);
+  const bodyStart = fullText.indexOf("{");
+  if (bodyStart === -1) return fullText;
+  return fullText.slice(0, bodyStart).trim();
+}
+function getClassSignature(node, sourceFile) {
+  const lines = node.getText(sourceFile).split("\n");
+  const sigLines = [];
+  for (const line of lines) {
+    sigLines.push(line);
+    if (line.includes("{")) break;
+  }
+  let sig = sigLines.join("\n");
+  const methods = node.members.filter((m) => ts.isMethodDeclaration(m)).map((m) => {
+    const methodSig = getSignatureText(m, sourceFile);
+    return `  ${methodSig}`;
+  });
+  if (methods.length > 0) {
+    sig += "\n" + methods.join("\n") + "\n}";
+  }
+  return sig;
+}
+function getJSDoc(node, sourceFile) {
+  const fullText = sourceFile.getFullText();
+  const ranges = ts.getLeadingCommentRanges(fullText, node.getFullStart());
+  if (!ranges) return void 0;
+  for (const range of ranges) {
+    const comment = fullText.slice(range.pos, range.end);
+    if (comment.startsWith("/**")) {
+      return comment;
+    }
+  }
+  return void 0;
+}
+function getParameters(params, sourceFile) {
+  return params.map((p) => ({
+    name: p.name.getText(sourceFile),
+    type: p.type ? p.type.getText(sourceFile) : void 0,
+    optional: !!p.questionToken,
+    defaultValue: p.initializer ? p.initializer.getText(sourceFile) : void 0
+  }));
+}
+function gatherImportContext(analysis, maxFiles = 5, maxCharsPerFile = 3e3) {
+  const contexts = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const imp of analysis.imports) {
+    if (!imp.isRelative) continue;
+    if (contexts.length >= maxFiles) break;
+    const resolvedPath = resolveImportPath(analysis.filePath, imp.source);
+    if (!resolvedPath || seen.has(resolvedPath)) continue;
+    seen.add(resolvedPath);
+    try {
+      let content = readFileSync(resolvedPath, "utf-8");
+      if (content.length > maxCharsPerFile) {
+        content = content.slice(0, maxCharsPerFile) + "\n// ... (truncated)";
+      }
+      contexts.push({
+        importPath: imp.source,
+        resolvedPath,
+        specifiers: imp.specifiers,
+        content
+      });
+    } catch {
+    }
+  }
+  return contexts;
+}
+function resolveImportPath(fromFile, importSource) {
+  const dir = dirname(fromFile);
+  const base = resolve(dir, importSource);
+  const extensions = [".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx", "/index.js"];
+  if (existsSync(base) && extname(base)) return base;
+  for (const ext of extensions) {
+    const candidate = base + ext;
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+
+// src/prompt/index.ts
+function buildSystemPrompt(config) {
+  const framework = config.framework;
+  const frameworkRules = {
+    vitest: `- ALWAYS start with: import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+- Use vi.fn() for mocking, vi.spyOn for spying`,
+    jest: `- Jest globals (describe, it, expect, jest) are available \u2014 do not import them
+- Use jest.fn() for mocking, jest.spyOn for spying`,
+    mocha: `- ALWAYS start with: import { describe, it } from 'mocha'; import { expect } from 'chai';
+- Use sinon for mocking if needed`,
+    node: `- ALWAYS start with: import { describe, it } from 'node:test'; import assert from 'node:assert/strict';
+- Use assert.strictEqual, assert.throws, assert.deepStrictEqual
+- Use t.mock for mocking`
+  };
+  return `You are an expert test engineer. You write comprehensive, production-quality ${framework} tests.
+
+Rules:
+- Use ${framework} syntax and conventions
+${frameworkRules[framework] ?? frameworkRules["vitest"]}
+- Write ONLY the test code \u2014 no explanations, no markdown fences, no commentary
+- Use descriptive test names that explain the expected behavior
+- Group related tests in describe blocks
+- Test both happy paths and edge cases
+- Test error conditions and boundary values
+- Import the module under test using the EXACT relative path provided
+- Ensure all tests are independent and can run in any order
+${config.instructions ? `
+Additional instructions: ${config.instructions}` : ""}`;
+}
+function buildUserPrompt(analysis, config, importContexts) {
+  const testableExports = analysis.exports.filter(
+    (e) => e.kind !== "type" && e.kind !== "interface"
+  );
+  if (testableExports.length === 0) {
+    return buildSimplePrompt(analysis);
+  }
+  const sections = [];
+  sections.push(`Generate comprehensive ${config.framework} tests for the following file.`);
+  sections.push(`
+File: ${analysis.fileName}`);
+  sections.push(`Language: ${analysis.language}`);
+  sections.push("\n## Exported Symbols to Test\n");
+  for (const sym of testableExports) {
+    sections.push(formatSymbolForPrompt(sym));
+  }
+  const importPath = `./${analysis.fileName.replace(/\.(ts|tsx|js|jsx)$/, "")}`;
+  const exportNames = testableExports.map((e) => e.isDefault ? `default as ${e.name}` : e.name);
+  const importLine = `import { ${exportNames.join(", ")} } from '${importPath}';`;
+  sections.push("\n## Requirements\n");
+  sections.push(`- Your test file MUST start with this exact import:
+  ${importLine}`);
+  sections.push(`- Import each function/class by name \u2014 do NOT use side-effect imports like \`import '${importPath}'\``);
+  if (config.edgeCases) {
+    sections.push("- Include edge case tests for boundary values (empty strings, 0, negative numbers, large inputs)");
+    sections.push("- Only test null/undefined if the source code explicitly handles them \u2014 JavaScript coerces null/undefined in arithmetic, so do NOT assume they throw");
+  }
+  if (config.errorHandling) {
+    sections.push("- Include error handling tests ONLY for errors explicitly thrown in the source code");
+    sections.push("- Read the source code carefully \u2014 only use toThrow/toThrowError for functions that actually have throw statements");
+  }
+  const asyncExports = testableExports.filter((e) => e.isAsync);
+  if (asyncExports.length > 0) {
+    sections.push(`- Use async/await for testing: ${asyncExports.map((e) => e.name).join(", ")}`);
+  }
+  sections.push("\n## Full Source Code\n");
+  sections.push("```" + analysis.language);
+  sections.push(analysis.sourceCode);
+  sections.push("```");
+  if (importContexts && importContexts.length > 0) {
+    sections.push("\n## Related Files (for context only \u2014 do NOT test these)\n");
+    for (const ctx of importContexts) {
+      sections.push(`### ${ctx.importPath} (imports: ${ctx.specifiers.join(", ")})
+`);
+      sections.push("```" + analysis.language);
+      sections.push(ctx.content);
+      sections.push("```\n");
+    }
+  }
+  sections.push("\nGenerate the test file now. Output ONLY valid test code, nothing else.");
+  return sections.join("\n");
+}
+function buildSimplePrompt(analysis) {
+  return `Generate comprehensive tests for the following ${analysis.language} file.
+
+File: ${analysis.fileName}
+Import from: './${analysis.fileName.replace(/\.(ts|tsx|js|jsx)$/, "")}'
+
+\`\`\`${analysis.language}
+${analysis.sourceCode}
+\`\`\`
+
+Generate the test file now. Output ONLY valid test code, nothing else.`;
+}
+function formatSymbolForPrompt(sym) {
+  const parts = [];
+  const prefix = sym.isDefault ? "(default export) " : "";
+  switch (sym.kind) {
+    case "function":
+    case "arrow-function": {
+      parts.push(`### ${prefix}\`${sym.name}\` (${sym.isAsync ? "async " : ""}function)`);
+      if (sym.parameters?.length) {
+        const params = sym.parameters.map((p) => `  - \`${p.name}\`: ${p.type ?? "any"}${p.optional ? " (optional)" : ""}${p.defaultValue ? ` = ${p.defaultValue}` : ""}`).join("\n");
+        parts.push(`Parameters:
+${params}`);
+      }
+      if (sym.returnType) {
+        parts.push(`Returns: \`${sym.returnType}\``);
+      }
+      break;
+    }
+    case "class": {
+      parts.push(`### ${prefix}\`${sym.name}\` (class)`);
+      parts.push(`Signature:
+\`\`\`
+${sym.signature}
+\`\`\``);
+      break;
+    }
+    case "variable": {
+      parts.push(`### \`${sym.name}\` (exported variable)`);
+      break;
+    }
+    case "enum": {
+      parts.push(`### \`${sym.name}\` (enum)`);
+      break;
+    }
+  }
+  if (sym.jsDoc) {
+    parts.push(`Documentation: ${sym.jsDoc}`);
+  }
+  return parts.join("\n") + "\n";
+}
+async function generateWithLLM(systemPrompt, userPrompt, config, onChunk) {
+  if (onChunk) {
+    const stream = await ai(
+      [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: userPrompt }
+      ],
+      {
+        provider: config.provider,
+        model: config.model,
+        apiKey: config.apiKey,
+        maxTokens: config.maxTokens,
+        temperature: config.temperature,
+        stream: true
+      }
+    );
+    let fullText = "";
+    for await (const chunk of stream) {
+      fullText += chunk;
+      onChunk(chunk);
+    }
+    const response2 = await stream.response();
+    return {
+      text: fullText,
+      tokensUsed: response2.usage.totalTokens
+    };
+  }
+  const response = await ai(
+    [
+      { role: "system", content: systemPrompt },
+      { role: "user", content: userPrompt }
+    ],
+    {
+      provider: config.provider,
+      model: config.model,
+      apiKey: config.apiKey,
+      maxTokens: config.maxTokens,
+      temperature: config.temperature
+    }
+  );
+  return {
+    text: response.text,
+    tokensUsed: response.usage.totalTokens
+  };
+}
+function parseTestOutput(raw, sourceFile, config) {
+  let code = raw.trim();
+  const fenceStart = code.indexOf("```");
+  if (fenceStart !== -1) {
+    code = code.slice(fenceStart);
+    const firstNewline = code.indexOf("\n");
+    code = code.slice(firstNewline + 1);
+    const lastFence = code.lastIndexOf("```");
+    if (lastFence !== -1) {
+      code = code.slice(0, lastFence);
+    }
+    code = code.trim();
+  }
+  const itMatches = code.match(/\bit\s*\(/g) || [];
+  const testMatches = code.match(/\btest\s*\(/g) || [];
+  const testCount = itMatches.length + testMatches.length;
+  const categories = extractCategories(code);
+  const testFile = getTestFilePath(sourceFile, config);
+  return {
+    sourceFile,
+    testFile,
+    testCode: code,
+    testCount,
+    categories
+  };
+}
+function writeTestFile(test, config) {
+  if (existsSync(test.testFile) && !config.overwrite) {
+    throw new Error(
+      `Test file already exists: ${test.testFile}. Use --overwrite to replace it.`
+    );
+  }
+  const dir = dirname(test.testFile);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(test.testFile, test.testCode + "\n", "utf-8");
+}
+function getTestFilePath(sourceFile, config) {
+  const ext = extname(sourceFile);
+  const base = basename(sourceFile, ext);
+  const dir = config.outDir ?? dirname(sourceFile);
+  return join(dir, `${base}.test${ext}`);
+}
+function extractCategories(code) {
+  const categories = [];
+  const describeRegex = /describe\s*\(\s*['"`]([^'"`]+)['"`]/g;
+  let match;
+  while ((match = describeRegex.exec(code)) !== null) {
+    const name = match[1];
+    const startIdx = match.index;
+    const nextDescribe = code.indexOf("describe(", startIdx + 1);
+    const block = nextDescribe === -1 ? code.slice(startIdx) : code.slice(startIdx, nextDescribe);
+    const itCount = (block.match(/\bit\s*\(/g) || []).length + (block.match(/\btest\s*\(/g) || []).length;
+    categories.push({ name, count: itCount });
+  }
+  return categories;
+}
+function runTestFile(testFile, framework, cwd) {
+  const resolvedCwd = cwd ?? findProjectRoot(testFile);
+  const cmd = buildRunCommand(framework, testFile);
+  try {
+    const output = execSync(cmd, {
+      cwd: resolvedCwd,
+      encoding: "utf-8",
+      timeout: 6e4,
+      env: { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1" },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return parseTestOutput2(output, framework, true);
+  } catch (err) {
+    const execErr = err;
+    const output = (execErr.stdout ?? "") + "\n" + (execErr.stderr ?? "");
+    return parseTestOutput2(output, framework, false);
+  }
+}
+function buildRunCommand(framework, testFile) {
+  switch (framework) {
+    case "vitest":
+      return `npx vitest run "${testFile}" --reporter=verbose 2>&1`;
+    case "jest":
+      return `npx jest "${testFile}" --verbose --no-coverage 2>&1`;
+    case "mocha":
+      return `npx mocha "${testFile}" --reporter spec 2>&1`;
+    case "node":
+      return `node --test "${testFile}" 2>&1`;
+  }
+}
+function parseTestOutput2(output, framework, exitedClean) {
+  const failures = extractFailures(output);
+  const counts = extractCounts(output);
+  const passed = exitedClean || failures.length === 0 && counts.total > 0;
+  return {
+    passed,
+    output,
+    failures,
+    totalTests: counts.total,
+    passedTests: counts.passed,
+    failedTests: counts.failed
+  };
+}
+function extractFailures(output, _framework) {
+  const failures = [];
+  const failPattern = /(?:FAIL|×|✕|✗|✖)\s+(.+?)(?:\n|\r\n)([\s\S]*?)(?=(?:FAIL|×|✕|✗|✖)\s|\n\s*(?:Tests|Test Files|Test Suites)|\n\s*$)/gi;
+  let match;
+  while ((match = failPattern.exec(output)) !== null) {
+    const testName = match[1]?.trim() ?? "unknown";
+    const errorBlock = match[2]?.trim() ?? "";
+    const expectedMatch = errorBlock.match(/Expected:?\s*(.+)/i);
+    const receivedMatch = errorBlock.match(/Received:?\s*(.+)/i);
+    failures.push({
+      testName,
+      error: errorBlock.slice(0, 500),
+      expected: expectedMatch?.[1]?.trim(),
+      received: receivedMatch?.[1]?.trim()
+    });
+  }
+  if (failures.length === 0 && output.includes("FAIL")) {
+    const errorLines = output.match(/(?:AssertionError|Error|ReferenceError|TypeError):.*$/gm);
+    if (errorLines) {
+      for (const line of errorLines) {
+        failures.push({
+          testName: "unknown",
+          error: line.trim()
+        });
+      }
+    }
+  }
+  if (failures.length === 0) {
+    const syntaxErr = output.match(/(?:SyntaxError|ERROR):\s*(.+)/);
+    if (syntaxErr) {
+      failures.push({
+        testName: "compilation",
+        error: syntaxErr[0].trim()
+      });
+    }
+  }
+  return failures;
+}
+function extractCounts(output, _framework) {
+  const vitestMatch = output.match(/Tests\s+(?:(\d+)\s+failed\s*\|?\s*)?(?:(\d+)\s+passed\s*)?\((\d+)\)/);
+  if (vitestMatch) {
+    const failed = parseInt(vitestMatch[1] ?? "0", 10);
+    const passed = parseInt(vitestMatch[2] ?? "0", 10);
+    const total = parseInt(vitestMatch[3], 10);
+    return { total, passed, failed: failed || total - passed };
+  }
+  const vitestAlt = output.match(/(\d+)\s+failed\s*\|\s*(\d+)\s+passed/);
+  if (vitestAlt) {
+    const failed = parseInt(vitestAlt[1], 10);
+    const passed = parseInt(vitestAlt[2], 10);
+    return { total: failed + passed, passed, failed };
+  }
+  const jestMatch = output.match(/Tests:\s+(?:(\d+)\s+failed,\s+)?(\d+)\s+passed,\s+(\d+)\s+total/);
+  if (jestMatch) {
+    const failed = parseInt(jestMatch[1] ?? "0", 10);
+    const passed = parseInt(jestMatch[2], 10);
+    const total = parseInt(jestMatch[3], 10);
+    return { total, passed, failed };
+  }
+  const filesPass = output.match(/Test Files\s+(\d+)\s+passed/);
+  const filesFail = output.match(/Test Files\s+(\d+)\s+failed/);
+  if (filesPass || filesFail) {
+    const passMarkers = (output.match(/✓|✔|√/g) || []).length;
+    const failMarkers = (output.match(/×|✕|✗|✖|❯/g) || []).length;
+    if (passMarkers + failMarkers > 0) {
+      return { total: passMarkers + failMarkers, passed: passMarkers, failed: failMarkers };
+    }
+  }
+  const passCount = (output.match(/✓|✔|√/g) || []).length;
+  const failCount = (output.match(/×|✕|✗|✖/g) || []).length;
+  return {
+    total: passCount + failCount,
+    passed: passCount,
+    failed: failCount
+  };
+}
+function findProjectRoot(fromFile) {
+  let dir = dirname(resolve(fromFile));
+  for (let i = 0; i < 10; i++) {
+    if (existsSync(resolve(dir, "package.json"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return dirname(resolve(fromFile));
+}
+async function fixFailingTests(sourceCode, testCode, failures, config, onChunk) {
+  const systemPrompt = buildFixSystemPrompt(config);
+  const userPrompt = buildFixUserPrompt(sourceCode, testCode, failures);
+  if (onChunk) {
+    const stream = await ai(
+      [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: userPrompt }
+      ],
+      {
+        provider: config.provider,
+        model: config.model,
+        apiKey: config.apiKey,
+        maxTokens: config.maxTokens,
+        temperature: config.temperature,
+        stream: true
+      }
+    );
+    let fullText = "";
+    for await (const chunk of stream) {
+      fullText += chunk;
+      onChunk(chunk);
+    }
+    return fullText;
+  }
+  const response = await ai(
+    [
+      { role: "system", content: systemPrompt },
+      { role: "user", content: userPrompt }
+    ],
+    {
+      provider: config.provider,
+      model: config.model,
+      apiKey: config.apiKey,
+      maxTokens: config.maxTokens,
+      temperature: config.temperature
+    }
+  );
+  return response.text;
+}
+function buildFixSystemPrompt(config) {
+  return `You are an expert test engineer fixing failing ${config.framework} tests.
+
+Rules:
+- Output ONLY the complete, corrected test file \u2014 no explanations, no markdown fences
+- Fix every failing test based on the actual error messages
+- If a test expected a function to throw but it doesn't, remove or rewrite the test to match actual behavior
+- If the expected value is wrong, correct it to match the actual source code behavior
+- Do NOT remove passing tests
+- Do NOT add new tests \u2014 only fix the broken ones
+- Keep all imports and structure intact
+- Read the source code carefully to understand what each function actually does`;
+}
+function buildFixUserPrompt(sourceCode, testCode, failures) {
+  const failureDetails = failures.map((f, i) => {
+    let detail = `${i + 1}. **${f.testName}**
+   Error: ${f.error}`;
+    if (f.expected) detail += `
+   Expected: ${f.expected}`;
+    if (f.received) detail += `
+   Received: ${f.received}`;
+    return detail;
+  }).join("\n\n");
+  return `Fix the failing tests below. The source code is the truth \u2014 adjust the tests to match it.
+
+## Source Code (DO NOT MODIFY)
+
+\`\`\`
+${sourceCode}
+\`\`\`
+
+## Current Test File (FIX THIS)
+
+\`\`\`
+${testCode}
+\`\`\`
+
+## Failures (${failures.length})
+
+${failureDetails}
+
+Output the COMPLETE fixed test file. Every test must pass.`;
+}
+
+// src/verify/index.ts
+async function verifyAndFix(sourceFile, testFile, config, options) {
+  const maxIterations = options?.maxIterations ?? 3;
+  const log = options?.onStatus ?? (() => {
+  });
+  const sourceCode = readFileSync(sourceFile, "utf-8");
+  for (let iteration = 1; iteration <= maxIterations; iteration++) {
+    log(`
+${pc.cyan("\u25B6")} Verify iteration ${iteration}/${maxIterations}...`);
+    const result = runTestFile(testFile, config.framework);
+    if (result.passed) {
+      log(`${pc.green("\u2714")} All ${result.totalTests} tests pass!`);
+      return {
+        passed: true,
+        iterations: iteration,
+        totalTests: result.totalTests,
+        passedTests: result.passedTests,
+        failedTests: 0,
+        finalTestCode: readFileSync(testFile, "utf-8")
+      };
+    }
+    log(
+      `${pc.yellow("\u26A0")} ${result.failedTests}/${result.totalTests} tests failed` + (iteration < maxIterations ? " \u2014 sending to LLM for auto-fix..." : "")
+    );
+    if (iteration >= maxIterations) {
+      return {
+        passed: false,
+        iterations: iteration,
+        totalTests: result.totalTests,
+        passedTests: result.passedTests,
+        failedTests: result.failedTests,
+        finalTestCode: readFileSync(testFile, "utf-8")
+      };
+    }
+    const currentTestCode = readFileSync(testFile, "utf-8");
+    if (options?.onChunk) options.onChunk("\n");
+    const fixedRaw = await fixFailingTests(
+      sourceCode,
+      currentTestCode,
+      result.failures,
+      config,
+      options?.onChunk
+    );
+    if (options?.onChunk) options.onChunk("\n");
+    const parsed = parseTestOutput(fixedRaw, sourceFile, config);
+    writeFileSync(testFile, parsed.testCode + "\n", "utf-8");
+    log(`${pc.dim("  Wrote fixed tests to")} ${testFile}`);
+  }
+  return {
+    passed: false,
+    iterations: maxIterations,
+    totalTests: 0,
+    passedTests: 0,
+    failedTests: 0,
+    finalTestCode: readFileSync(testFile, "utf-8")
+  };
+}
+
+// src/generate.ts
+async function generateTests(sourceFile, config, options) {
+  const start = Date.now();
+  const analysis = analyzeFile(sourceFile);
+  const importContexts = gatherImportContext(analysis);
+  const systemPrompt = buildSystemPrompt(config);
+  const userPrompt = buildUserPrompt(analysis, config, importContexts);
+  const llmResult = await generateWithLLM(
+    systemPrompt,
+    userPrompt,
+    config,
+    options?.onChunk
+  );
+  const generatedTest = parseTestOutput(llmResult.text, sourceFile, config);
+  if (!options?.dryRun) {
+    writeTestFile(generatedTest, config);
+  }
+  const result = {
+    sourceFile: generatedTest.sourceFile,
+    testFile: generatedTest.testFile,
+    testCount: generatedTest.testCount,
+    categories: generatedTest.categories,
+    duration: Date.now() - start,
+    tokensUsed: llmResult.tokensUsed
+  };
+  if (options?.verify && !options?.dryRun) {
+    const verifyResult = await verifyAndFix(
+      sourceFile,
+      generatedTest.testFile,
+      config,
+      {
+        maxIterations: options.maxFixIterations ?? 3,
+        onChunk: options.onChunk,
+        onStatus: options.onStatus
+      }
+    );
+    result.verified = verifyResult.passed;
+    result.verifyIterations = verifyResult.iterations;
+    result.testCount = verifyResult.totalTests;
+    result.duration = Date.now() - start;
+  }
+  return result;
+}
+
+// src/frameworks/index.ts
+var FRAMEWORKS = {
+  vitest: {
+    name: "vitest",
+    imports: "import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';",
+    runCommand: "npx vitest run",
+    filePattern: "**/*.test.{ts,tsx,js,jsx}",
+    coverageCommand: "npx vitest run --coverage --reporter=lcov"
+  },
+  jest: {
+    name: "jest",
+    imports: "// Jest globals available",
+    runCommand: "npx jest",
+    filePattern: "**/*.test.{ts,tsx,js,jsx}",
+    coverageCommand: "npx jest --coverage --coverageReporters=lcov"
+  },
+  mocha: {
+    name: "mocha",
+    imports: "import { describe, it, before, after, beforeEach, afterEach } from 'mocha';\nimport { expect } from 'chai';",
+    runCommand: "npx mocha",
+    filePattern: "**/*.test.{ts,tsx,js,jsx}",
+    coverageCommand: "npx c8 mocha"
+  },
+  node: {
+    name: "node",
+    imports: "import { describe, it, before, after, beforeEach, afterEach } from 'node:test';\nimport assert from 'node:assert/strict';",
+    runCommand: "node --test",
+    filePattern: "**/*.test.{ts,tsx,js,jsx}",
+    coverageCommand: "node --test --experimental-test-coverage"
+  }
+};
+function getFrameworkInfo(framework) {
+  return FRAMEWORKS[framework];
+}
+function detectFramework(packageJson) {
+  const deps = {
+    ...packageJson["devDependencies"],
+    ...packageJson["dependencies"]
+  };
+  if (deps["vitest"]) return "vitest";
+  if (deps["jest"] || deps["@jest/core"]) return "jest";
+  if (deps["mocha"]) return "mocha";
+  const scripts = packageJson["scripts"];
+  if (scripts) {
+    const testScript = scripts["test"] ?? "";
+    if (testScript.includes("vitest")) return "vitest";
+    if (testScript.includes("jest")) return "jest";
+    if (testScript.includes("mocha")) return "mocha";
+    if (testScript.includes("node --test")) return "node";
+  }
+  return "vitest";
+}
+
+// src/types.ts
+var DEFAULT_CONFIG = {
+  provider: "openai",
+  framework: "vitest",
+  overwrite: false,
+  edgeCases: true,
+  errorHandling: true,
+  maxTokens: 4096,
+  temperature: 0.2
+};
+
+// src/config/index.ts
+var CONFIG_FILES = [
+  "autotest.config.json",
+  ".autotestrc",
+  ".autotestrc.json"
+];
+function resolveConfig(cliFlags, cwd = process.cwd()) {
+  const fileConfig = loadConfigFile(cwd);
+  const pkgConfig = loadFromPackageJson(cwd);
+  const detectedFramework = detectFrameworkFromProject(cwd);
+  return {
+    ...DEFAULT_CONFIG,
+    ...detectedFramework && { framework: detectedFramework },
+    ...pkgConfig,
+    ...fileConfig,
+    ...stripUndefined(cliFlags)
+  };
+}
+function loadConfigFile(cwd) {
+  for (const fileName of CONFIG_FILES) {
+    const filePath = resolve(cwd, fileName);
+    if (existsSync(filePath)) {
+      try {
+        const content = readFileSync(filePath, "utf-8");
+        return JSON.parse(content);
+      } catch {
+      }
+    }
+  }
+  return {};
+}
+function loadFromPackageJson(cwd) {
+  const pkgPath = resolve(cwd, "package.json");
+  if (!existsSync(pkgPath)) return {};
+  try {
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    return pkg["autotest"] ?? {};
+  } catch {
+    return {};
+  }
+}
+function detectFrameworkFromProject(cwd) {
+  const pkgPath = resolve(cwd, "package.json");
+  if (!existsSync(pkgPath)) return void 0;
+  try {
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    return detectFramework(pkg);
+  } catch {
+    return void 0;
+  }
+}
+function stripUndefined(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value !== void 0) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function parseLcov(lcovPath, cwd) {
+  const content = readFileSync(lcovPath, "utf-8");
+  const files = [];
+  let currentFile = null;
+  let linesHit = 0;
+  let linesFound = 0;
+  let branchesHit = 0;
+  let branchesFound = 0;
+  const uncoveredLines = [];
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("SF:")) {
+      currentFile = trimmed.slice(3);
+      linesHit = 0;
+      linesFound = 0;
+      branchesHit = 0;
+      branchesFound = 0;
+      uncoveredLines.length = 0;
+    } else if (trimmed.startsWith("DA:")) {
+      const parts = trimmed.slice(3).split(",");
+      const lineNum = parseInt(parts[0], 10);
+      const hits = parseInt(parts[1], 10);
+      linesFound++;
+      if (hits > 0) {
+        linesHit++;
+      } else {
+        uncoveredLines.push(lineNum);
+      }
+    } else if (trimmed.startsWith("BRF:")) {
+      branchesFound = parseInt(trimmed.slice(4), 10);
+    } else if (trimmed.startsWith("BRH:")) {
+      branchesHit = parseInt(trimmed.slice(4), 10);
+    } else if (trimmed === "end_of_record" && currentFile) {
+      const filePath = resolve(currentFile);
+      const relPath = relative(cwd, filePath);
+      const ext = filePath.match(/\.(ts|tsx|js|jsx)$/)?.[0] ?? ".ts";
+      const base = basename(filePath, ext);
+      const testFile = filePath.replace(
+        new RegExp(`${base.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}${ext.replace(".", "\\.")}$`),
+        `${base}.test${ext}`
+      );
+      files.push({
+        filePath,
+        relativePath: relPath,
+        lineRate: linesFound > 0 ? linesHit / linesFound : 0,
+        branchRate: branchesFound > 0 ? branchesHit / branchesFound : 0,
+        uncoveredLines: [...uncoveredLines],
+        totalLines: linesFound,
+        coveredLines: linesHit,
+        hasTests: existsSync(testFile)
+      });
+      currentFile = null;
+    }
+  }
+  const totalLines = files.reduce((s, f) => s + f.totalLines, 0);
+  const coveredLines = files.reduce((s, f) => s + f.coveredLines, 0);
+  return {
+    files,
+    totalLines,
+    coveredLines,
+    overallRate: totalLines > 0 ? coveredLines / totalLines : 0
+  };
+}
+function parseCobertura(xmlPath, cwd) {
+  const content = readFileSync(xmlPath, "utf-8");
+  const files = [];
+  const classRegex = /<class\s[^>]*filename="([^"]+)"[^>]*line-rate="([^"]+)"[^>]*branch-rate="([^"]+)"[^>]*>/g;
+  let match;
+  while ((match = classRegex.exec(content)) !== null) {
+    const filename = match[1];
+    const lineRate = parseFloat(match[2]);
+    const branchRate = parseFloat(match[3]);
+    const filePath = resolve(cwd, filename);
+    const relPath = relative(cwd, filePath);
+    const uncoveredLines = [];
+    const fileSection = content.slice(match.index, content.indexOf("</class>", match.index));
+    const lineRegex = /<line\s+number="(\d+)"\s+hits="(\d+)"/g;
+    let lineMatch;
+    let total = 0;
+    let covered = 0;
+    while ((lineMatch = lineRegex.exec(fileSection)) !== null) {
+      total++;
+      const lineNum = parseInt(lineMatch[1], 10);
+      const hits = parseInt(lineMatch[2], 10);
+      if (hits > 0) {
+        covered++;
+      } else {
+        uncoveredLines.push(lineNum);
+      }
+    }
+    const ext = filePath.match(/\.(ts|tsx|js|jsx)$/)?.[0] ?? ".ts";
+    const base = basename(filePath, ext);
+    const testFile = filePath.replace(
+      new RegExp(`${base.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}${ext.replace(".", "\\.")}$`),
+      `${base}.test${ext}`
+    );
+    files.push({
+      filePath,
+      relativePath: relPath,
+      lineRate,
+      branchRate,
+      uncoveredLines,
+      totalLines: total || Math.round(1 / (1 - lineRate + 1e-3)),
+      coveredLines: covered || Math.round(lineRate * (total || 10)),
+      hasTests: existsSync(testFile)
+    });
+  }
+  const totalLines = files.reduce((s, f) => s + f.totalLines, 0);
+  const coveredLines = files.reduce((s, f) => s + f.coveredLines, 0);
+  return {
+    files,
+    totalLines,
+    coveredLines,
+    overallRate: totalLines > 0 ? coveredLines / totalLines : 0
+  };
+}
+function loadCoverage(cwd) {
+  const lcovPaths = [
+    "coverage/lcov.info",
+    "coverage/lcov/lcov.info"
+  ];
+  for (const p of lcovPaths) {
+    const fullPath = resolve(cwd, p);
+    if (existsSync(fullPath)) return parseLcov(fullPath, cwd);
+  }
+  const coberturaPaths = [
+    "coverage/cobertura-coverage.xml",
+    "coverage/cobertura.xml"
+  ];
+  for (const p of coberturaPaths) {
+    const fullPath = resolve(cwd, p);
+    if (existsSync(fullPath)) return parseCobertura(fullPath, cwd);
+  }
+  return null;
+}
+function getUncoveredFiles(coverage, targetRate = 0.8) {
+  return coverage.files.filter((f) => f.lineRate < targetRate).filter((f) => !f.relativePath.includes(".test.") && !f.relativePath.includes(".spec.")).filter((f) => !f.relativePath.includes("node_modules")).sort((a, b) => a.lineRate - b.lineRate);
+}
+
+export { DEFAULT_CONFIG, analyzeFile, detectFramework, gatherImportContext, generateTests, getFrameworkInfo, getUncoveredFiles, loadCoverage, parseCobertura, parseLcov, resolveConfig, runTestFile, verifyAndFix };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map