@kakarot-ci/core 0.2.0 → 0.3.0

package/dist/index.js

@@ -3,12 +3,15 @@ import { z } from "zod";
 var KakarotConfigSchema = z.object({
   apiKey: z.string(),
   githubToken: z.string().optional(),
+  githubOwner: z.string().optional(),
+  githubRepo: z.string().optional(),
   provider: z.enum(["openai", "anthropic", "google"]).optional(),
   model: z.string().optional(),
   maxTokens: z.number().int().min(1).max(1e5).optional(),
   temperature: z.number().min(0).max(2).optional(),
   fixTemperature: z.number().min(0).max(2).optional(),
   maxFixAttempts: z.number().int().min(0).max(5).default(3),
+  framework: z.enum(["jest", "vitest"]),
   testLocation: z.enum(["separate", "co-located"]).default("separate"),
   testDirectory: z.string().default("__tests__"),
   testFilePattern: z.string().default("*.test.ts"),
@@ -22,8 +25,8 @@ var KakarotConfigSchema = z.object({
 });
 
 // src/utils/config-loader.ts
-import { existsSync, readFileSync } from "fs";
-import { join, dirname } from "path";
+import { cosmiconfig } from "cosmiconfig";
+import { findUp } from "find-up";
 
 // src/utils/logger.ts
 var debugMode = false;
@@ -78,108 +81,70 @@ function progress(step, total, message, ...args) {
 }
 
 // src/utils/config-loader.ts
-function findProjectRoot(startPath) {
-  const start = startPath ?? process.cwd();
-  let current = start;
-  let previous = null;
-  while (current !== previous) {
-    if (existsSync(join(current, "package.json"))) {
-      return current;
-    }
-    previous = current;
-    current = dirname(current);
-  }
-  return start;
-}
-async function loadTypeScriptConfig(root) {
-  const configPath = join(root, "kakarot.config.ts");
-  if (!existsSync(configPath)) {
-    return null;
-  }
-  try {
-    const configModule = await import(configPath);
-    return configModule.default || configModule.config || null;
-  } catch (err) {
-    error(`Failed to load kakarot.config.ts: ${err instanceof Error ? err.message : String(err)}`);
-    return null;
-  }
-}
-async function loadJavaScriptConfig(root) {
-  const configPath = join(root, ".kakarot-ci.config.js");
-  if (!existsSync(configPath)) {
-    return null;
-  }
-  try {
-    const configModule = await import(configPath);
-    return configModule.default || configModule.config || null;
-  } catch (err) {
-    error(`Failed to load .kakarot-ci.config.js: ${err instanceof Error ? err.message : String(err)}`);
-    return null;
-  }
-}
-function loadJsonConfig(root) {
-  const configPath = join(root, ".kakarot-ci.config.json");
-  if (!existsSync(configPath)) {
-    return null;
-  }
-  try {
-    const content = readFileSync(configPath, "utf-8");
-    return JSON.parse(content);
-  } catch (err) {
-    error(`Failed to load .kakarot-ci.config.json: ${err instanceof Error ? err.message : String(err)}`);
-    return null;
-  }
-}
-function loadPackageJsonConfig(root) {
-  const packagePath = join(root, "package.json");
-  if (!existsSync(packagePath)) {
-    return null;
-  }
-  try {
-    const content = readFileSync(packagePath, "utf-8");
-    const pkg = JSON.parse(content);
-    return pkg.kakarotCi || null;
-  } catch (err) {
-    error(`Failed to load package.json: ${err instanceof Error ? err.message : String(err)}`);
-    return null;
-  }
-}
-function mergeEnvConfig(config) {
-  const merged = { ...config };
-  if (!merged.apiKey && process.env.KAKAROT_API_KEY) {
-    merged.apiKey = process.env.KAKAROT_API_KEY;
-  }
-  if (!merged.githubToken && process.env.GITHUB_TOKEN) {
-    merged.githubToken = process.env.GITHUB_TOKEN;
+async function findProjectRoot(startPath) {
+  const packageJsonPath = await findUp("package.json", {
+    cwd: startPath ?? process.cwd()
+  });
+  if (packageJsonPath) {
+    const { dirname: dirname2 } = await import("path");
+    return dirname2(packageJsonPath);
   }
-  return merged;
+  return startPath ?? process.cwd();
 }
 async function loadConfig() {
-  const projectRoot = findProjectRoot();
-  let config = null;
-  config = await loadTypeScriptConfig(projectRoot);
-  if (config) {
-    return KakarotConfigSchema.parse(mergeEnvConfig(config));
-  }
-  config = await loadJavaScriptConfig(projectRoot);
-  if (config) {
-    return KakarotConfigSchema.parse(mergeEnvConfig(config));
-  }
-  config = loadJsonConfig(projectRoot);
-  if (config) {
-    return KakarotConfigSchema.parse(mergeEnvConfig(config));
-  }
-  config = loadPackageJsonConfig(projectRoot);
-  if (config) {
-    return KakarotConfigSchema.parse(mergeEnvConfig(config));
-  }
-  const envConfig = mergeEnvConfig({});
+  const explorer = cosmiconfig("kakarot", {
+    searchPlaces: [
+      "kakarot.config.ts",
+      "kakarot.config.js",
+      ".kakarot-ci.config.ts",
+      ".kakarot-ci.config.js",
+      ".kakarot-ci.config.json",
+      "package.json"
+    ],
+    loaders: {
+      ".ts": async (filepath) => {
+        try {
+          const configModule = await import(filepath);
+          return configModule.default || configModule.config || null;
+        } catch (err) {
+          error(`Failed to load TypeScript config: ${err instanceof Error ? err.message : String(err)}`);
+          return null;
+        }
+      }
+    }
+  });
   try {
-    return KakarotConfigSchema.parse(envConfig);
+    const result = await explorer.search();
+    let config = {};
+    if (result?.config) {
+      config = result.config;
+    }
+    if (!result || result.filepath?.endsWith("package.json")) {
+      const packageJsonPath = await findUp("package.json");
+      if (packageJsonPath) {
+        const { readFileSync: readFileSync2 } = await import("fs");
+        try {
+          const pkg = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
+          if (pkg.kakarotCi) {
+            config = { ...config, ...pkg.kakarotCi };
+          }
+        } catch {
+        }
+      }
+    }
+    if (!config.apiKey && process.env.KAKAROT_API_KEY) {
+      config.apiKey = process.env.KAKAROT_API_KEY;
+    }
+    if (!config.githubToken && process.env.GITHUB_TOKEN) {
+      config.githubToken = process.env.GITHUB_TOKEN;
+    }
+    return KakarotConfigSchema.parse(config);
   } catch (err) {
-    error(
-      "Missing required apiKey. Provide it via:\n  - Config file (kakarot.config.ts, .kakarot-ci.config.js/json, or package.json)\n  - Environment variable: KAKAROT_API_KEY"
-    );
+    if (err instanceof Error && err.message.includes("apiKey")) {
+      error(
+        "Missing required apiKey. Provide it via:\n  - Config file (kakarot.config.ts, .kakarot-ci.config.js/json, or package.json)\n  - Environment variable: KAKAROT_API_KEY"
+      );
+    }
     throw err;
   }
 }
@@ -785,6 +750,29 @@ async function extractTestTargets(files, githubClient, prHeadRef, config) {
   return targets;
 }
 
+// src/utils/test-file-path.ts
+function getTestFilePath(target, config) {
+  const sourcePath = target.filePath;
+  const dir = sourcePath.substring(0, sourcePath.lastIndexOf("/"));
+  const baseName = sourcePath.substring(sourcePath.lastIndexOf("/") + 1).replace(/\.(ts|tsx|js|jsx)$/, "");
+  let ext;
+  if (sourcePath.endsWith(".tsx"))
+    ext = "tsx";
+  else if (sourcePath.endsWith(".jsx"))
+    ext = "jsx";
+  else if (sourcePath.endsWith(".ts"))
+    ext = "ts";
+  else
+    ext = "js";
+  const testExt = ext === "tsx" || ext === "ts" ? "ts" : "js";
+  if (config.testLocation === "co-located") {
+    return `${dir}/${baseName}.test.${testExt}`;
+  } else {
+    const testFileName = config.testFilePattern.replace("*", baseName);
+    return `${config.testDirectory}/${testFileName}`;
+  }
+}
+
 // src/llm/providers/base.ts
 var BaseLLMProvider = class {
   constructor(apiKey, model, defaultOptions) {
@@ -1356,27 +1344,790 @@ var TestGenerator = class {
       throw err;
     }
   }
+  /**
+   * Generate a human-readable coverage summary
+   */
+  async generateCoverageSummary(messages) {
+    try {
+      const response = await this.provider.generate(messages, {
+        temperature: 0.3,
+        maxTokens: 500
+      });
+      return response.content;
+    } catch (err) {
+      error(`Failed to generate coverage summary: ${err instanceof Error ? err.message : String(err)}`);
+      throw err;
+    }
+  }
+};
+
+// src/utils/package-manager-detector.ts
+import { existsSync } from "fs";
+import { join } from "path";
+function detectPackageManager(projectRoot) {
+  if (existsSync(join(projectRoot, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (existsSync(join(projectRoot, "yarn.lock"))) {
+    return "yarn";
+  }
+  if (existsSync(join(projectRoot, "package-lock.json"))) {
+    return "npm";
+  }
+  return "npm";
+}
+
+// src/utils/test-runner/jest-runner.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+var JestRunner = class {
+  async runTests(options) {
+    const { testFiles, packageManager, projectRoot, coverage } = options;
+    debug(`Running Jest tests for ${testFiles.length} file(s)`);
+    const testFilesArg = testFiles.map((f) => `"${f}"`).join(" ");
+    const coverageFlag = coverage ? "--coverage --coverageReporters=json" : "--no-coverage";
+    const cmd = `${packageManager} test -- --json ${coverageFlag} ${testFilesArg}`;
+    try {
+      const { stdout, stderr } = await execAsync(cmd, {
+        cwd: projectRoot,
+        maxBuffer: 10 * 1024 * 1024
+        // 10MB
+      });
+      if (stderr && !stderr.includes("PASS") && !stderr.includes("FAIL")) {
+        debug(`Jest stderr: ${stderr}`);
+      }
+      const result = JSON.parse(stdout);
+      return testFiles.map((testFile, index) => {
+        const testResult = result.testResults[index] || result.testResults[0];
+        const failures = [];
+        if (testResult) {
+          for (const assertion of testResult.assertionResults) {
+            if (assertion.status === "failed" && assertion.failureMessages.length > 0) {
+              const failureMessage = assertion.failureMessages[0];
+              failures.push({
+                testName: assertion.title,
+                message: failureMessage,
+                stack: failureMessage
+              });
+            }
+          }
+        }
+        return {
+          success: result.numFailedTests === 0,
+          testFile,
+          passed: result.numPassedTests,
+          failed: result.numFailedTests,
+          total: result.numTotalTests,
+          duration: 0,
+          // Jest JSON doesn't include duration per file
+          failures
+        };
+      });
+    } catch (err) {
+      if (err && typeof err === "object" && "stdout" in err) {
+        try {
+          const result = JSON.parse(err.stdout);
+          return testFiles.map((testFile) => {
+            const failures = [];
+            for (const testResult of result.testResults) {
+              for (const assertion of testResult.assertionResults) {
+                if (assertion.status === "failed" && assertion.failureMessages.length > 0) {
+                  failures.push({
+                    testName: assertion.title,
+                    message: assertion.failureMessages[0],
+                    stack: assertion.failureMessages[0]
+                  });
+                }
+              }
+            }
+            return {
+              success: result.numFailedTests === 0,
+              testFile,
+              passed: result.numPassedTests,
+              failed: result.numFailedTests,
+              total: result.numTotalTests,
+              duration: 0,
+              failures
+            };
+          });
+        } catch (parseErr) {
+          error(`Failed to parse Jest output: ${parseErr instanceof Error ? parseErr.message : String(parseErr)}`);
+          throw err;
+        }
+      }
+      error(`Jest test execution failed: ${err instanceof Error ? err.message : String(err)}`);
+      throw err;
+    }
+  }
 };
+
+// src/utils/test-runner/vitest-runner.ts
+import { exec as exec2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execAsync2 = promisify2(exec2);
+var VitestRunner = class {
+  async runTests(options) {
+    const { testFiles, packageManager, projectRoot, coverage } = options;
+    debug(`Running Vitest tests for ${testFiles.length} file(s)`);
+    const testFilesArg = testFiles.map((f) => `"${f}"`).join(" ");
+    const coverageFlag = coverage ? "--coverage" : "";
+    const cmd = `${packageManager} test -- --reporter=json ${coverageFlag} ${testFilesArg}`;
+    try {
+      const { stdout, stderr } = await execAsync2(cmd, {
+        cwd: projectRoot,
+        maxBuffer: 10 * 1024 * 1024
+        // 10MB
+      });
+      if (stderr && !stderr.includes("PASS") && !stderr.includes("FAIL")) {
+        debug(`Vitest stderr: ${stderr}`);
+      }
+      const lines = stdout.trim().split("\n");
+      const jsonLine = lines[lines.length - 1];
+      if (!jsonLine || !jsonLine.startsWith("{")) {
+        throw new Error("No valid JSON output from Vitest");
+      }
+      const result = JSON.parse(jsonLine);
+      return testFiles.map((testFile, index) => {
+        const testResult = result.testResults[index] || result.testResults[0];
+        const failures = [];
+        if (testResult) {
+          for (const assertion of testResult.assertionResults) {
+            if (assertion.status === "failed" && assertion.failureMessages.length > 0) {
+              const failureMessage = assertion.failureMessages[0];
+              failures.push({
+                testName: assertion.title,
+                message: failureMessage,
+                stack: failureMessage
+              });
+            }
+          }
+        }
+        return {
+          success: result.numFailedTests === 0,
+          testFile,
+          passed: result.numPassedTests,
+          failed: result.numFailedTests,
+          total: result.numTotalTests,
+          duration: 0,
+          // Vitest JSON doesn't include duration per file
+          failures
+        };
+      });
+    } catch (err) {
+      if (err && typeof err === "object" && "stdout" in err) {
+        try {
+          const lines = err.stdout.trim().split("\n");
+          const jsonLine = lines[lines.length - 1];
+          if (jsonLine && jsonLine.startsWith("{")) {
+            const result = JSON.parse(jsonLine);
+            return testFiles.map((testFile) => {
+              const failures = [];
+              for (const testResult of result.testResults) {
+                for (const assertion of testResult.assertionResults) {
+                  if (assertion.status === "failed" && assertion.failureMessages.length > 0) {
+                    failures.push({
+                      testName: assertion.title,
+                      message: assertion.failureMessages[0],
+                      stack: assertion.failureMessages[0]
+                    });
+                  }
+                }
+              }
+              return {
+                success: result.numFailedTests === 0,
+                testFile,
+                passed: result.numPassedTests,
+                failed: result.numFailedTests,
+                total: result.numTotalTests,
+                duration: 0,
+                failures
+              };
+            });
+          }
+        } catch (parseErr) {
+          error(`Failed to parse Vitest output: ${parseErr instanceof Error ? parseErr.message : String(parseErr)}`);
+          throw err;
+        }
+      }
+      error(`Vitest test execution failed: ${err instanceof Error ? err.message : String(err)}`);
+      throw err;
+    }
+  }
+};
+
+// src/utils/test-runner/factory.ts
+function createTestRunner(framework) {
+  switch (framework) {
+    case "jest":
+      return new JestRunner();
+    case "vitest":
+      return new VitestRunner();
+    default:
+      throw new Error(`Unsupported test framework: ${framework}`);
+  }
+}
+
+// src/utils/test-file-writer.ts
+import { writeFileSync, mkdirSync, existsSync as existsSync2 } from "fs";
+import { dirname, join as join2 } from "path";
+function writeTestFiles(testFiles, projectRoot) {
+  const writtenPaths = [];
+  for (const [relativePath, fileData] of testFiles.entries()) {
+    const fullPath = join2(projectRoot, relativePath);
+    const dir = dirname(fullPath);
+    if (!existsSync2(dir)) {
+      mkdirSync(dir, { recursive: true });
+      debug(`Created directory: ${dir}`);
+    }
+    writeFileSync(fullPath, fileData.content, "utf-8");
+    writtenPaths.push(relativePath);
+    debug(`Wrote test file: ${relativePath}`);
+  }
+  return writtenPaths;
+}
+
+// src/utils/coverage-reader.ts
+import { readFileSync, existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+function parseJestCoverage(data) {
+  const files = [];
+  let totalStatements = 0;
+  let coveredStatements = 0;
+  let totalBranches = 0;
+  let coveredBranches = 0;
+  let totalFunctions = 0;
+  let coveredFunctions = 0;
+  let totalLines = 0;
+  let coveredLines = 0;
+  for (const [filePath, coverage] of Object.entries(data)) {
+    const statementCounts = Object.values(coverage.statements);
+    const branchCounts = Object.values(coverage.branches);
+    const functionCounts = Object.values(coverage.functions);
+    const lineCounts = Object.values(coverage.lines);
+    const fileStatements = {
+      total: statementCounts.length,
+      covered: statementCounts.filter((c) => c > 0).length,
+      percentage: statementCounts.length > 0 ? statementCounts.filter((c) => c > 0).length / statementCounts.length * 100 : 100
+    };
+    const fileBranches = {
+      total: branchCounts.length,
+      covered: branchCounts.filter((c) => c > 0).length,
+      percentage: branchCounts.length > 0 ? branchCounts.filter((c) => c > 0).length / branchCounts.length * 100 : 100
+    };
+    const fileFunctions = {
+      total: functionCounts.length,
+      covered: functionCounts.filter((c) => c > 0).length,
+      percentage: functionCounts.length > 0 ? functionCounts.filter((c) => c > 0).length / functionCounts.length * 100 : 100
+    };
+    const fileLines = {
+      total: lineCounts.length,
+      covered: lineCounts.filter((c) => c > 0).length,
+      percentage: lineCounts.length > 0 ? lineCounts.filter((c) => c > 0).length / lineCounts.length * 100 : 100
+    };
+    files.push({
+      path: filePath,
+      metrics: {
+        statements: fileStatements,
+        branches: fileBranches,
+        functions: fileFunctions,
+        lines: fileLines
+      }
+    });
+    totalStatements += fileStatements.total;
+    coveredStatements += fileStatements.covered;
+    totalBranches += fileBranches.total;
+    coveredBranches += fileBranches.covered;
+    totalFunctions += fileFunctions.total;
+    coveredFunctions += fileFunctions.covered;
+    totalLines += fileLines.total;
+    coveredLines += fileLines.covered;
+  }
+  return {
+    total: {
+      statements: {
+        total: totalStatements,
+        covered: coveredStatements,
+        percentage: totalStatements > 0 ? coveredStatements / totalStatements * 100 : 100
+      },
+      branches: {
+        total: totalBranches,
+        covered: coveredBranches,
+        percentage: totalBranches > 0 ? coveredBranches / totalBranches * 100 : 100
+      },
+      functions: {
+        total: totalFunctions,
+        covered: coveredFunctions,
+        percentage: totalFunctions > 0 ? coveredFunctions / totalFunctions * 100 : 100
+      },
+      lines: {
+        total: totalLines,
+        covered: coveredLines,
+        percentage: totalLines > 0 ? coveredLines / totalLines * 100 : 100
+      }
+    },
+    files
+  };
+}
+function parseVitestCoverage(data) {
+  return parseJestCoverage(data);
+}
+function readCoverageReport(projectRoot, framework) {
+  const coveragePath = join3(projectRoot, "coverage", "coverage-final.json");
+  if (!existsSync3(coveragePath)) {
+    debug(`Coverage file not found at ${coveragePath}`);
+    return null;
+  }
+  try {
+    const content = readFileSync(coveragePath, "utf-8");
+    const data = JSON.parse(content);
+    if (framework === "jest") {
+      return parseJestCoverage(data);
+    } else {
+      return parseVitestCoverage(data);
+    }
+  } catch (err) {
+    warn(`Failed to read coverage report: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+}
+
+// src/llm/prompts/coverage-summary.ts
+function buildCoverageSummaryPrompt(coverageReport, testResults, functionsTested, coverageDelta) {
+  const systemPrompt = `You are a technical writer specializing in test coverage reports. Your task is to generate a clear, concise, and actionable summary of test coverage metrics.
+
+Requirements:
+1. Use clear, professional language
+2. Highlight key metrics (lines, branches, functions, statements)
+3. Mention which functions were tested
+4. If coverage delta is provided, explain the change
+5. Provide actionable insights or recommendations
+6. Format as markdown suitable for GitHub PR comments
+7. Keep it concise (2-3 paragraphs max)`;
+  const totalTests = testResults.reduce((sum, r) => sum + r.total, 0);
+  const passedTests = testResults.reduce((sum, r) => sum + r.passed, 0);
+  const failedTests = testResults.reduce((sum, r) => sum + r.failed, 0);
+  const userPrompt = `Generate a human-readable test coverage summary with the following information:
+
+**Coverage Metrics:**
+- Lines: ${coverageReport.total.lines.percentage.toFixed(1)}% (${coverageReport.total.lines.covered}/${coverageReport.total.lines.total})
+- Branches: ${coverageReport.total.branches.percentage.toFixed(1)}% (${coverageReport.total.branches.covered}/${coverageReport.total.branches.total})
+- Functions: ${coverageReport.total.functions.percentage.toFixed(1)}% (${coverageReport.total.functions.covered}/${coverageReport.total.functions.total})
+- Statements: ${coverageReport.total.statements.percentage.toFixed(1)}% (${coverageReport.total.statements.covered}/${coverageReport.total.statements.total})
+
+**Test Results:**
+- Total tests: ${totalTests}
+- Passed: ${passedTests}
+- Failed: ${failedTests}
+
+**Functions Tested:**
+${functionsTested.length > 0 ? functionsTested.map((f) => `- ${f}`).join("\n") : "None"}
+
+${coverageDelta ? `**Coverage Changes:**
+- Lines: ${coverageDelta.lines > 0 ? "+" : ""}${coverageDelta.lines.toFixed(1)}%
+- Branches: ${coverageDelta.branches > 0 ? "+" : ""}${coverageDelta.branches.toFixed(1)}%
+- Functions: ${coverageDelta.functions > 0 ? "+" : ""}${coverageDelta.functions.toFixed(1)}%
+- Statements: ${coverageDelta.statements > 0 ? "+" : ""}${coverageDelta.statements.toFixed(1)}%
+` : ""}
+
+Generate a concise, professional summary that explains what was tested and the coverage achieved.`;
+  return [
+    { role: "system", content: systemPrompt },
+    { role: "user", content: userPrompt }
+  ];
+}
+
+// src/core/orchestrator.ts
+async function runPullRequest(context) {
+  const config = await loadConfig();
+  initLogger(config);
+  info(`Processing PR #${context.prNumber} for ${context.owner}/${context.repo}`);
+  const githubToken = context.githubToken || config.githubToken;
+  if (!githubToken) {
+    throw new Error("GitHub token is required. Provide it via config.githubToken or context.githubToken");
+  }
+  const githubClient = new GitHubClient({
+    token: githubToken,
+    owner: context.owner,
+    repo: context.repo
+  });
+  const pr = await githubClient.getPullRequest(context.prNumber);
+  if (pr.state !== "open") {
+    warn(`PR #${context.prNumber} is ${pr.state}, skipping test generation`);
+    return {
+      targetsProcessed: 0,
+      testsGenerated: 0,
+      testsFailed: 0,
+      testFiles: [],
+      errors: []
+    };
+  }
+  info(`PR: ${pr.title} (${pr.head.ref} -> ${pr.base.ref})`);
+  const prFiles = await githubClient.listPullRequestFiles(context.prNumber);
+  if (prFiles.length === 0) {
+    info("No files changed in this PR");
+    return {
+      targetsProcessed: 0,
+      testsGenerated: 0,
+      testsFailed: 0,
+      testFiles: [],
+      errors: []
+    };
+  }
+  info(`Found ${prFiles.length} file(s) changed in PR`);
+  const prHeadRef = pr.head.sha;
+  const targets = await extractTestTargets(
+    prFiles,
+    githubClient,
+    prHeadRef,
+    config
+  );
+  if (targets.length === 0) {
+    info("No test targets found in changed files");
+    return {
+      targetsProcessed: 0,
+      testsGenerated: 0,
+      testsFailed: 0,
+      testFiles: [],
+      errors: []
+    };
+  }
+  const limitedTargets = targets.slice(0, config.maxTestsPerPR);
+  if (targets.length > limitedTargets.length) {
+    warn(`Limiting to ${config.maxTestsPerPR} test targets (found ${targets.length})`);
+  }
+  info(`Found ${limitedTargets.length} test target(s)`);
+  const framework = config.framework;
+  info(`Using test framework: ${framework}`);
+  const testGenerator = new TestGenerator({
+    apiKey: config.apiKey,
+    provider: config.provider,
+    model: config.model,
+    maxTokens: config.maxTokens,
+    maxFixAttempts: config.maxFixAttempts,
+    temperature: config.temperature,
+    fixTemperature: config.fixTemperature
+  });
+  let testFiles = /* @__PURE__ */ new Map();
+  const errors = [];
+  let testsGenerated = 0;
+  let testsFailed = 0;
+  for (let i = 0; i < limitedTargets.length; i++) {
+    const target = limitedTargets[i];
+    progress(i + 1, limitedTargets.length, `Generating test for ${target.functionName}`);
+    try {
+      const testFilePath = getTestFilePath(target, config);
+      let existingTestFile;
+      const testFileExists = await githubClient.fileExists(prHeadRef, testFilePath);
+      if (testFileExists) {
+        try {
+          const fileContents = await githubClient.getFileContents(prHeadRef, testFilePath);
+          existingTestFile = fileContents.content;
+          debug(`Found existing test file at ${testFilePath}`);
+        } catch (err) {
+          debug(`Could not fetch existing test file ${testFilePath}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      } else {
+        debug(`No existing test file at ${testFilePath}, will create new file`);
+      }
+      const result = await testGenerator.generateTest({
+        target: {
+          filePath: target.filePath,
+          functionName: target.functionName,
+          functionType: target.functionType,
+          code: target.code,
+          context: target.context
+        },
+        framework,
+        existingTestFile
+      });
+      if (!testFiles.has(testFilePath)) {
+        const baseContent = existingTestFile || "";
+        testFiles.set(testFilePath, { content: baseContent, targets: [] });
+      }
+      const fileData = testFiles.get(testFilePath);
+      if (fileData.content) {
+        fileData.content += "\n\n" + result.testCode;
+      } else {
+        fileData.content = result.testCode;
+      }
+      fileData.targets.push(target.functionName);
+      testsGenerated++;
+      info(`\u2713 Generated test for ${target.functionName}`);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      error(`\u2717 Failed to generate test for ${target.functionName}: ${errorMessage}`);
+      errors.push({
+        target: `${target.filePath}:${target.functionName}`,
+        error: errorMessage
+      });
+      testsFailed++;
+    }
+  }
+  const projectRoot = await findProjectRoot();
+  const packageManager = detectPackageManager(projectRoot);
+  info(`Detected package manager: ${packageManager}`);
+  if (testFiles.size > 0) {
+    const writtenPaths = writeTestFiles(testFiles, projectRoot);
+    info(`Wrote ${writtenPaths.length} test file(s) to disk`);
+    const testRunner = createTestRunner(framework);
+    const finalTestFiles = await runTestsAndFix(
+      testRunner,
+      testFiles,
+      writtenPaths,
+      framework,
+      packageManager,
+      projectRoot,
+      testGenerator,
+      config.maxFixAttempts
+    );
+    testFiles = finalTestFiles;
+  }
+  const summary = {
+    targetsProcessed: limitedTargets.length,
+    testsGenerated,
+    testsFailed,
+    testFiles: Array.from(testFiles.entries()).map(([path, data]) => ({
+      path,
+      targets: data.targets
+    })),
+    errors
+  };
+  if (testFiles.size > 0) {
+    const testRunner = createTestRunner(framework);
+    const writtenPaths = Array.from(testFiles.keys());
+    info("Running tests with coverage...");
+    const finalTestResults = await testRunner.runTests({
+      testFiles: writtenPaths,
+      framework,
+      packageManager,
+      projectRoot,
+      coverage: true
+    });
+    const coverageReport = readCoverageReport(projectRoot, framework);
+    if (coverageReport) {
+      info(`Coverage collected: ${coverageReport.total.lines.percentage.toFixed(1)}% lines`);
+      summary.coverageReport = coverageReport;
+      summary.testResults = finalTestResults;
+    } else {
+      warn("Could not read coverage report");
+    }
+  }
+  if (config.enableAutoCommit && testFiles.size > 0) {
+    await commitTests(
+      githubClient,
+      pr,
+      Array.from(testFiles.entries()).map(([path, data]) => ({
+        path,
+        content: data.content
+      })),
+      config,
+      summary
+    );
+  }
+  if (config.enablePRComments) {
+    await postPRComment(githubClient, context.prNumber, summary, framework, testGenerator);
+  }
+  success(`Completed: ${testsGenerated} test(s) generated, ${testsFailed} failed`);
+  return summary;
+}
+async function runTestsAndFix(testRunner, testFiles, testFilePaths, framework, packageManager, projectRoot, testGenerator, maxFixAttempts) {
+  const currentTestFiles = new Map(testFiles);
+  let attempt = 0;
+  while (attempt < maxFixAttempts) {
+    info(`Running tests (attempt ${attempt + 1}/${maxFixAttempts})`);
+    const results = await testRunner.runTests({
+      testFiles: testFilePaths,
+      framework,
+      packageManager,
+      projectRoot,
+      coverage: false
+    });
+    const allPassed = results.every((r) => r.success);
+    if (allPassed) {
+      success(`All tests passed on attempt ${attempt + 1}`);
+      return currentTestFiles;
+    }
+    const failures = [];
+    for (const result of results) {
+      if (!result.success && result.failures.length > 0) {
+        failures.push({ testFile: result.testFile, result });
+      }
+    }
+    info(`Found ${failures.length} failing test file(s), attempting fixes...`);
+    let fixedAny = false;
+    for (const { testFile, result } of failures) {
+      const testFileContent = currentTestFiles.get(testFile)?.content;
+      if (!testFileContent) {
+        warn(`Could not find content for test file: ${testFile}`);
+        continue;
+      }
+      const firstFailure = result.failures[0];
+      if (!firstFailure)
+        continue;
+      try {
+        const fixedResult = await testGenerator.fixTest({
+          testCode: testFileContent,
+          errorMessage: firstFailure.message,
+          testOutput: firstFailure.stack,
+          originalCode: "",
+          // We'd need to pass this from the target
+          framework,
+          attempt: attempt + 1,
+          maxAttempts: maxFixAttempts
+        });
+        currentTestFiles.set(testFile, {
+          content: fixedResult.testCode,
+          targets: currentTestFiles.get(testFile)?.targets || []
+        });
+        const { writeFileSync: writeFileSync2 } = await import("fs");
+        const { join: join4 } = await import("path");
+        writeFileSync2(join4(projectRoot, testFile), fixedResult.testCode, "utf-8");
+        fixedAny = true;
+        info(`\u2713 Fixed test file: ${testFile}`);
+      } catch (err) {
+        error(`Failed to fix test file ${testFile}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    if (!fixedAny) {
+      warn(`Could not fix any failing tests on attempt ${attempt + 1}`);
+      break;
+    }
+    attempt++;
+  }
+  if (attempt >= maxFixAttempts) {
+    warn(`Reached maximum fix attempts (${maxFixAttempts}), some tests may still be failing`);
+  }
+  return currentTestFiles;
+}
+async function commitTests(githubClient, pr, testFiles, config, summary) {
+  info(`Committing ${testFiles.length} test file(s)`);
+  try {
+    if (config.commitStrategy === "branch-pr") {
+      const branchName = `kakarot-ci/tests-pr-${pr.number}`;
+      const baseSha = await githubClient.createBranch(branchName, pr.head.ref);
+      await githubClient.commitFiles({
+        files: testFiles.map((file) => ({
+          path: file.path,
+          content: file.content
+        })),
+        message: `test: add unit tests for PR #${pr.number}
+
+Generated ${summary.testsGenerated} test(s) for ${summary.targetsProcessed} function(s)`,
+        branch: branchName,
+        baseSha
+      });
+      const testPR = await githubClient.createPullRequest(
+        `test: Add unit tests for PR #${pr.number}`,
+        `This PR contains automatically generated unit tests for PR #${pr.number}.
+
+- ${summary.testsGenerated} test(s) generated
+- ${summary.targetsProcessed} function(s) tested
+- ${testFiles.length} test file(s) created/updated`,
+        branchName,
+        pr.head.ref
+      );
+      success(`Created PR #${testPR.number} with generated tests`);
+    } else {
+      await githubClient.commitFiles({
+        files: testFiles.map((file) => ({
+          path: file.path,
+          content: file.content
+        })),
+        message: `test: add unit tests
+
+Generated ${summary.testsGenerated} test(s) for ${summary.targetsProcessed} function(s)`,
+        branch: pr.head.ref,
+        baseSha: pr.head.sha
+      });
+      success(`Committed ${testFiles.length} test file(s) to ${pr.head.ref}`);
+    }
+  } catch (err) {
+    error(`Failed to commit tests: ${err instanceof Error ? err.message : String(err)}`);
+    throw err;
+  }
+}
+async function postPRComment(githubClient, prNumber, summary, framework, testGenerator) {
+  let comment = `## \u{1F9EA} Kakarot CI Test Generation Summary
+
+**Framework:** ${framework}
+**Targets Processed:** ${summary.targetsProcessed}
+**Tests Generated:** ${summary.testsGenerated}
+**Failures:** ${summary.testsFailed}
+
+### Test Files
+${summary.testFiles.length > 0 ? summary.testFiles.map((f) => `- \`${f.path}\` (${f.targets.length} test(s))`).join("\n") : "No test files generated"}
+
+${summary.errors.length > 0 ? `### Errors
+${summary.errors.map((e) => `- \`${e.target}\`: ${e.error}`).join("\n")}` : ""}`;
+  if (summary.coverageReport && summary.testResults) {
+    try {
+      const functionsTested = summary.testFiles.flatMap((f) => f.targets);
+      const messages = buildCoverageSummaryPrompt(
+        summary.coverageReport,
+        summary.testResults,
+        functionsTested
+      );
+      const coverageSummary = await testGenerator.generateCoverageSummary(messages);
+      comment += `
+
+## \u{1F4CA} Coverage Summary
+
+${coverageSummary}`;
+    } catch (err) {
+      warn(`Failed to generate coverage summary: ${err instanceof Error ? err.message : String(err)}`);
+      const cov = summary.coverageReport.total;
+      comment += `
+
+## \u{1F4CA} Coverage Summary
+
+- **Lines:** ${cov.lines.percentage.toFixed(1)}% (${cov.lines.covered}/${cov.lines.total})
+- **Branches:** ${cov.branches.percentage.toFixed(1)}% (${cov.branches.covered}/${cov.branches.total})
+- **Functions:** ${cov.functions.percentage.toFixed(1)}% (${cov.functions.covered}/${cov.functions.total})
+- **Statements:** ${cov.statements.percentage.toFixed(1)}% (${cov.statements.covered}/${cov.statements.total})`;
+    }
+  }
+  comment += `
+
+---
+*Generated by [Kakarot CI](https://github.com/kakarot-ci)*`;
+  try {
+    await githubClient.commentPR(prNumber, comment);
+    info("Posted PR comment with test generation summary");
+  } catch (err) {
+    warn(`Failed to post PR comment: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
 export {
   GitHubClient,
+  JestRunner,
   KakarotConfigSchema,
   TestGenerator,
+  VitestRunner,
   analyzeFile,
+  buildCoverageSummaryPrompt,
   buildTestFixPrompt,
   buildTestGenerationPrompt,
   createLLMProvider,
+  createTestRunner,
   debug,
+  detectPackageManager,
   error,
   extractTestTargets,
+  findProjectRoot,
   getChangedRanges,
+  getTestFilePath,
   info,
   initLogger,
   loadConfig,
   parsePullRequestFiles,
   parseTestCode,
   progress,
+  readCoverageReport,
+  runPullRequest,
   success,
   validateTestCodeStructure,
-  warn
+  warn,
+  writeTestFiles
 };
 //# sourceMappingURL=index.js.map