@kakarot-ci/core 0.2.0 → 0.3.0

package/dist/cli/index.js

@@ -0,0 +1,2288 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { simpleGit } from "simple-git";
+import gitUrlParse from "git-url-parse";
+import { Command } from "commander";
+
+// src/github/client.ts
+import { Octokit } from "@octokit/rest";
+
+// src/utils/logger.ts
+var debugMode = false;
+var jsonMode = false;
+function initLogger(config) {
+  debugMode = config.debug ?? process.env.KAKAROT_DEBUG === "true";
+  jsonMode = process.env.KAKAROT_OUTPUT === "json";
+}
+function info(message, ...args) {
+  if (jsonMode) {
+    console.log(JSON.stringify({ level: "info", message, ...args }));
+  } else {
+    console.log(`[kakarot-ci] ${message}`, ...args);
+  }
+}
+function debug(message, ...args) {
+  if (debugMode) {
+    if (jsonMode) {
+      console.debug(JSON.stringify({ level: "debug", message, ...args }));
+    } else {
+      console.debug(`[kakarot-ci:debug] ${message}`, ...args);
+    }
+  }
+}
+function warn(message, ...args) {
+  if (jsonMode) {
+    console.warn(JSON.stringify({ level: "warn", message, ...args }));
+  } else {
+    console.warn(`[kakarot-ci] \u26A0 ${message}`, ...args);
+  }
+}
+function error(message, ...args) {
+  if (jsonMode) {
+    console.error(JSON.stringify({ level: "error", message, ...args }));
+  } else {
+    console.error(`[kakarot-ci] \u2717 ${message}`, ...args);
+  }
+}
+function success(message, ...args) {
+  if (jsonMode) {
+    console.log(JSON.stringify({ level: "success", message, ...args }));
+  } else {
+    console.log(`[kakarot-ci] \u2713 ${message}`, ...args);
+  }
+}
+function progress(step, total, message, ...args) {
+  if (jsonMode) {
+    console.log(JSON.stringify({ level: "info", step, total, message, ...args }));
+  } else {
+    console.log(`[kakarot-ci] Step ${step}/${total}: ${message}`, ...args);
+  }
+}
+
+// src/github/client.ts
+var GitHubClient = class {
+  // 1 second
+  constructor(options) {
+    this.maxRetries = 3;
+    this.retryDelay = 1e3;
+    this.owner = options.owner;
+    this.repo = options.repo;
+    this.octokit = new Octokit({
+      auth: options.token,
+      request: {
+        retries: this.maxRetries,
+        retryAfter: this.retryDelay / 1e3
+      }
+    });
+  }
+  /**
+   * Retry wrapper with exponential backoff
+   */
+  async withRetry(fn, operation, retries = this.maxRetries) {
+    try {
+      return await fn();
+    } catch (err) {
+      if (retries <= 0) {
+        error(`${operation} failed after ${this.maxRetries} retries: ${err instanceof Error ? err.message : String(err)}`);
+        throw err;
+      }
+      const isRateLimit = err instanceof Error && err.message.includes("rate limit");
+      const isServerError = err instanceof Error && (err.message.includes("500") || err.message.includes("502") || err.message.includes("503") || err.message.includes("504"));
+      if (isRateLimit || isServerError) {
+        const delay = this.retryDelay * Math.pow(2, this.maxRetries - retries);
+        warn(`${operation} failed, retrying in ${delay}ms... (${retries} retries left)`);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        return this.withRetry(fn, operation, retries - 1);
+      }
+      throw err;
+    }
+  }
+  /**
+   * Get pull request details
+   */
+  async getPullRequest(prNumber) {
+    return this.withRetry(async () => {
+      debug(`Fetching PR #${prNumber}`);
+      const response = await this.octokit.rest.pulls.get({
+        owner: this.owner,
+        repo: this.repo,
+        pull_number: prNumber
+      });
+      return response.data;
+    }, `getPullRequest(${prNumber})`);
+  }
+  /**
+   * List all files changed in a pull request with patches
+   */
+  async listPullRequestFiles(prNumber) {
+    return this.withRetry(async () => {
+      debug(`Fetching files for PR #${prNumber}`);
+      const response = await this.octokit.rest.pulls.listFiles({
+        owner: this.owner,
+        repo: this.repo,
+        pull_number: prNumber
+      });
+      return response.data.map((file) => ({
+        filename: file.filename,
+        status: file.status,
+        additions: file.additions,
+        deletions: file.deletions,
+        changes: file.changes,
+        patch: file.patch || void 0,
+        previous_filename: file.previous_filename || void 0
+      }));
+    }, `listPullRequestFiles(${prNumber})`);
+  }
+  /**
+   * Get file contents from a specific ref (branch, commit, etc.)
+   */
+  async getFileContents(ref, path) {
+    return this.withRetry(async () => {
+      debug(`Fetching file contents: ${path}@${ref}`);
+      const response = await this.octokit.rest.repos.getContent({
+        owner: this.owner,
+        repo: this.repo,
+        path,
+        ref
+      });
+      if (Array.isArray(response.data)) {
+        throw new Error(`Expected file but got directory: ${path}`);
+      }
+      const data = response.data;
+      let content;
+      if (data.encoding === "base64") {
+        content = Buffer.from(data.content, "base64").toString("utf-8");
+      } else {
+        content = data.content;
+      }
+      return {
+        content,
+        encoding: data.encoding,
+        sha: data.sha,
+        size: data.size
+      };
+    }, `getFileContents(${ref}, ${path})`);
+  }
+  /**
+   * Commit multiple files in a single commit using Git tree API
+   */
+  async commitFiles(options) {
+    return this.withRetry(async () => {
+      debug(`Committing ${options.files.length} file(s) to branch ${options.branch}`);
+      const baseCommit = await this.octokit.rest.repos.getCommit({
+        owner: this.owner,
+        repo: this.repo,
+        ref: options.baseSha
+      });
+      const baseTreeSha = baseCommit.data.commit.tree.sha;
+      const blobPromises = options.files.map(async (file) => {
+        const blobResponse = await this.octokit.rest.git.createBlob({
+          owner: this.owner,
+          repo: this.repo,
+          content: Buffer.from(file.content, "utf-8").toString("base64"),
+          encoding: "base64"
+        });
+        return {
+          path: file.path,
+          sha: blobResponse.data.sha,
+          mode: "100644",
+          type: "blob"
+        };
+      });
+      const treeItems = await Promise.all(blobPromises);
+      const treeResponse = await this.octokit.rest.git.createTree({
+        owner: this.owner,
+        repo: this.repo,
+        base_tree: baseTreeSha,
+        tree: treeItems
+      });
+      const commitResponse = await this.octokit.rest.git.createCommit({
+        owner: this.owner,
+        repo: this.repo,
+        message: options.message,
+        tree: treeResponse.data.sha,
+        parents: [options.baseSha]
+      });
+      await this.octokit.rest.git.updateRef({
+        owner: this.owner,
+        repo: this.repo,
+        ref: `heads/${options.branch}`,
+        sha: commitResponse.data.sha
+      });
+      return commitResponse.data.sha;
+    }, `commitFiles(${options.files.length} files)`);
+  }
+  /**
+   * Create a new branch from a base ref
+   */
+  async createBranch(branchName, baseRef) {
+    return this.withRetry(async () => {
+      debug(`Creating branch ${branchName} from ${baseRef}`);
+      const baseRefResponse = await this.octokit.rest.git.getRef({
+        owner: this.owner,
+        repo: this.repo,
+        ref: baseRef.startsWith("refs/") ? baseRef : `heads/${baseRef}`
+      });
+      const baseSha = baseRefResponse.data.object.sha;
+      await this.octokit.rest.git.createRef({
+        owner: this.owner,
+        repo: this.repo,
+        ref: `refs/heads/${branchName}`,
+        sha: baseSha
+      });
+      return baseSha;
+    }, `createBranch(${branchName})`);
+  }
+  /**
+   * Create a pull request
+   */
+  async createPullRequest(title, body, head, base) {
+    return this.withRetry(async () => {
+      debug(`Creating PR: ${head} -> ${base}`);
+      const response = await this.octokit.rest.pulls.create({
+        owner: this.owner,
+        repo: this.repo,
+        title,
+        body,
+        head,
+        base
+      });
+      return response.data;
+    }, `createPullRequest(${head} -> ${base})`);
+  }
+  /**
+   * Post a comment on a pull request
+   */
+  async commentPR(prNumber, body) {
+    await this.withRetry(async () => {
+      debug(`Posting comment on PR #${prNumber}`);
+      await this.octokit.rest.issues.createComment({
+        owner: this.owner,
+        repo: this.repo,
+        issue_number: prNumber,
+        body
+      });
+    }, `commentPR(${prNumber})`);
+  }
+  /**
+   * Check if a file exists in the repository
+   */
+  async fileExists(ref, path) {
+    return this.withRetry(async () => {
+      try {
+        await this.octokit.rest.repos.getContent({
+          owner: this.owner,
+          repo: this.repo,
+          path,
+          ref
+        });
+        return true;
+      } catch (err) {
+        if (err instanceof Error && err.message.includes("404")) {
+          return false;
+        }
+        throw err;
+      }
+    }, `fileExists(${ref}, ${path})`);
+  }
+  /**
+   * Get the current rate limit status
+   */
+  async getRateLimit() {
+    const response = await this.octokit.rest.rateLimit.get();
+    return {
+      remaining: response.data.rate.remaining,
+      reset: response.data.rate.reset
+    };
+  }
+};
+
+// src/utils/config-loader.ts
+import { cosmiconfig } from "cosmiconfig";
+import { findUp } from "find-up";
+
+// src/types/config.ts
+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"),
+  includePatterns: z.array(z.string()).default(["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx"]),
+  excludePatterns: z.array(z.string()).default(["**/*.test.ts", "**/*.spec.ts", "**/*.test.js", "**/*.spec.js", "**/node_modules/**"]),
+  maxTestsPerPR: z.number().int().min(1).default(50),
+  enableAutoCommit: z.boolean().default(true),
+  commitStrategy: z.enum(["direct", "branch-pr"]).default("direct"),
+  enablePRComments: z.boolean().default(true),
+  debug: z.boolean().default(false)
+});
+
+// src/utils/config-loader.ts
+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 startPath ?? process.cwd();
+}
+async function loadConfig() {
+  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 {
+    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: readFileSync3 } = await import("fs");
+        try {
+          const pkg = JSON.parse(readFileSync3(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) {
+    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;
+  }
+}
+
+// src/utils/diff-parser.ts
+function parseUnifiedDiff(patch) {
+  const hunks = [];
+  const lines = patch.split("\n");
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const hunkMatch = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+    if (hunkMatch) {
+      const oldStart = parseInt(hunkMatch[1], 10);
+      const oldLines = parseInt(hunkMatch[2] || "1", 10);
+      const newStart = parseInt(hunkMatch[3], 10);
+      const newLines = parseInt(hunkMatch[4] || "1", 10);
+      const hunkLines = [];
+      i++;
+      while (i < lines.length && !lines[i].startsWith("@@")) {
+        hunkLines.push(lines[i]);
+        i++;
+      }
+      hunks.push({
+        oldStart,
+        oldLines,
+        newStart,
+        newLines,
+        lines: hunkLines
+      });
+    } else {
+      i++;
+    }
+  }
+  return hunks;
+}
+function hunksToChangedRanges(hunks) {
+  const ranges = [];
+  for (const hunk of hunks) {
+    let oldLine = hunk.oldStart;
+    let newLine = hunk.newStart;
+    for (const line of hunk.lines) {
+      if (line.startsWith("+") && !line.startsWith("+++")) {
+        ranges.push({
+          start: newLine,
+          end: newLine,
+          type: "addition"
+        });
+        newLine++;
+      } else if (line.startsWith("-") && !line.startsWith("---")) {
+        ranges.push({
+          start: oldLine,
+          end: oldLine,
+          type: "deletion"
+        });
+        oldLine++;
+      } else if (!line.startsWith("\\")) {
+        oldLine++;
+        newLine++;
+      }
+    }
+  }
+  return mergeRanges(ranges);
+}
+function mergeRanges(ranges) {
+  if (ranges.length === 0)
+    return [];
+  const sorted = [...ranges].sort((a, b) => a.start - b.start);
+  const merged = [];
+  let current = sorted[0];
+  for (let i = 1; i < sorted.length; i++) {
+    const next = sorted[i];
+    if (next.start <= current.end + 2 && next.type === current.type) {
+      current = {
+        start: current.start,
+        end: Math.max(current.end, next.end),
+        type: current.type
+      };
+    } else {
+      merged.push(current);
+      current = next;
+    }
+  }
+  merged.push(current);
+  return merged;
+}
+function parsePullRequestFiles(files) {
+  const diffs = [];
+  for (const file of files) {
+    if (!file.filename.match(/\.(ts|tsx|js|jsx)$/)) {
+      continue;
+    }
+    if (!file.patch) {
+      diffs.push({
+        filename: file.filename,
+        status: file.status,
+        hunks: [],
+        additions: file.additions,
+        deletions: file.deletions
+      });
+      continue;
+    }
+    const hunks = parseUnifiedDiff(file.patch);
+    diffs.push({
+      filename: file.filename,
+      status: file.status,
+      hunks,
+      additions: file.additions,
+      deletions: file.deletions
+    });
+    debug(`Parsed ${hunks.length} hunk(s) for ${file.filename}`);
+  }
+  return diffs;
+}
+function getChangedRanges(diff, fileContent) {
+  if (diff.status === "added") {
+    if (!fileContent) {
+      throw new Error("fileContent is required for added files to determine line count");
+    }
+    const lineCount = fileContent.split("\n").length;
+    return [{ start: 1, end: lineCount, type: "addition" }];
+  }
+  if (diff.status === "removed") {
+    return [];
+  }
+  return hunksToChangedRanges(diff.hunks);
+}
+
+// src/utils/ast-analyzer.ts
+import * as ts from "typescript";
+function extractFunctions(sourceFile) {
+  const functions = [];
+  function visit(node) {
+    if (ts.isFunctionDeclaration(node)) {
+      const isExported = node.modifiers?.some(
+        (m) => m.kind === ts.SyntaxKind.ExportKeyword || m.kind === ts.SyntaxKind.DefaultKeyword
+      );
+      if (node.name) {
+        functions.push({
+          name: node.name.text,
+          type: "function",
+          start: node.getStart(sourceFile),
+          end: node.getEnd(),
+          node
+        });
+      } else if (isExported) {
+        functions.push({
+          name: "default",
+          type: "function",
+          start: node.getStart(sourceFile),
+          end: node.getEnd(),
+          node
+        });
+      }
+    }
+    if (ts.isExportAssignment(node) && node.isExportEquals === false && ts.isFunctionExpression(node.expression)) {
+      const func = node.expression;
+      const name = func.name ? func.name.text : "default";
+      functions.push({
+        name,
+        type: "function",
+        start: node.getStart(sourceFile),
+        end: node.getEnd(),
+        node
+      });
+    }
+    if (ts.isMethodDeclaration(node) && node.name && ts.isIdentifier(node.name)) {
+      functions.push({
+        name: node.name.text,
+        type: "class-method",
+        start: node.getStart(sourceFile),
+        end: node.getEnd(),
+        node
+      });
+    }
+    if (ts.isVariableStatement(node)) {
+      for (const declaration of node.declarationList.declarations) {
+        if (declaration.initializer) {
+          if (ts.isArrowFunction(declaration.initializer)) {
+            if (ts.isIdentifier(declaration.name)) {
+              functions.push({
+                name: declaration.name.text,
+                type: "arrow-function",
+                start: declaration.getStart(sourceFile),
+                end: declaration.getEnd(),
+                node: declaration
+              });
+            }
+          } else if (ts.isFunctionExpression(declaration.initializer)) {
+            const funcExpr = declaration.initializer;
+            const name = funcExpr.name ? funcExpr.name.text : ts.isIdentifier(declaration.name) ? declaration.name.text : "anonymous";
+            if (name !== "anonymous") {
+              functions.push({
+                name,
+                type: "function",
+                start: declaration.getStart(sourceFile),
+                end: declaration.getEnd(),
+                node: declaration
+              });
+            }
+          }
+        }
+      }
+    }
+    if (ts.isPropertyAssignment(node) && ts.isIdentifier(node.name)) {
+      if (ts.isFunctionExpression(node.initializer) || ts.isArrowFunction(node.initializer)) {
+        functions.push({
+          name: node.name.text,
+          type: "method",
+          start: node.getStart(sourceFile),
+          end: node.getEnd(),
+          node
+        });
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return functions;
+}
+function getLineNumber(source, position) {
+  return source.substring(0, position).split("\n").length;
+}
+function functionOverlapsChanges(func, changedRanges, source) {
+  const funcStartLine = getLineNumber(source, func.start);
+  const funcEndLine = getLineNumber(source, func.end);
+  const additionRanges = changedRanges.filter((r) => r.type === "addition");
+  for (const range of additionRanges) {
+    if (range.start >= funcStartLine && range.start <= funcEndLine || range.end >= funcStartLine && range.end <= funcEndLine || range.start <= funcStartLine && range.end >= funcEndLine) {
+      return true;
+    }
+  }
+  return false;
+}
+function extractCodeSnippet(source, func) {
+  return source.substring(func.start, func.end);
+}
+function extractContext(source, func, allFunctions) {
+  const funcStartLine = getLineNumber(source, func.start);
+  const funcEndLine = getLineNumber(source, func.end);
+  const previousFunc = allFunctions.filter((f) => getLineNumber(source, f.end) < funcStartLine).sort((a, b) => getLineNumber(source, b.end) - getLineNumber(source, a.end))[0];
+  const contextStart = previousFunc ? getLineNumber(source, previousFunc.start) : Math.max(1, funcStartLine - 10);
+  const lines = source.split("\n");
+  const contextLines = lines.slice(contextStart - 1, funcEndLine + 5);
+  return contextLines.join("\n");
+}
+async function detectTestFile(filePath, ref, githubClient, testDirectory) {
+  const dir = filePath.substring(0, filePath.lastIndexOf("/"));
+  const baseName = filePath.substring(filePath.lastIndexOf("/") + 1).replace(/\.(ts|tsx|js|jsx)$/, "");
+  let ext;
+  if (filePath.endsWith(".tsx"))
+    ext = "tsx";
+  else if (filePath.endsWith(".jsx"))
+    ext = "jsx";
+  else if (filePath.endsWith(".ts"))
+    ext = "ts";
+  else
+    ext = "js";
+  const testPatterns = ext === "tsx" ? [`.test.tsx`, `.spec.tsx`, `.test.ts`, `.spec.ts`] : ext === "jsx" ? [`.test.jsx`, `.spec.jsx`, `.test.js`, `.spec.js`] : ext === "ts" ? [`.test.ts`, `.spec.ts`] : [`.test.js`, `.spec.js`];
+  const locations = [
+    // Co-located in same directory
+    ...testPatterns.map((pattern) => `${dir}/${baseName}${pattern}`),
+    // Co-located __tests__ directory
+    ...testPatterns.map((pattern) => `${dir}/__tests__/${baseName}${pattern}`),
+    // Test directory at root
+    ...testPatterns.map((pattern) => `${testDirectory}/${baseName}${pattern}`),
+    // Nested test directory matching source structure
+    ...testPatterns.map((pattern) => `${testDirectory}${dir}/${baseName}${pattern}`),
+    // __tests__ at root
+    ...testPatterns.map((pattern) => `__tests__/${baseName}${pattern}`)
+  ];
+  for (const testPath of locations) {
+    const exists = await githubClient.fileExists(ref, testPath);
+    if (exists) {
+      return testPath;
+    }
+  }
+  return void 0;
+}
+async function analyzeFile(filePath, content, changedRanges, ref, githubClient, testDirectory) {
+  const sourceFile = ts.createSourceFile(
+    filePath,
+    content,
+    ts.ScriptTarget.Latest,
+    true
+  );
+  const functions = extractFunctions(sourceFile);
+  const existingTestFile = await detectTestFile(filePath, ref, githubClient, testDirectory);
+  const targets = [];
+  for (const func of functions) {
+    if (functionOverlapsChanges(func, changedRanges, content)) {
+      const startLine = getLineNumber(content, func.start);
+      const endLine = getLineNumber(content, func.end);
+      targets.push({
+        filePath,
+        functionName: func.name,
+        functionType: func.type,
+        startLine,
+        endLine,
+        code: extractCodeSnippet(content, func),
+        context: extractContext(content, func, functions),
+        existingTestFile,
+        changedRanges: changedRanges.filter(
+          (r) => r.start >= startLine && r.end <= endLine
+        )
+      });
+      debug(`Found test target: ${func.name} (${func.type}) in ${filePath}${existingTestFile ? ` - existing test: ${existingTestFile}` : ""}`);
+    }
+  }
+  return targets;
+}
+
+// src/utils/test-target-extractor.ts
+async function extractTestTargets(files, githubClient, prHeadRef, config) {
+  info(`Analyzing ${files.length} file(s) for test targets`);
+  const diffs = parsePullRequestFiles(files);
+  const filteredDiffs = diffs.filter((diff) => {
+    const matchesInclude = config.includePatterns.some((pattern) => {
+      const regex = new RegExp(pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*"));
+      return regex.test(diff.filename);
+    });
+    if (!matchesInclude)
+      return false;
+    const matchesExclude = config.excludePatterns.some((pattern) => {
+      const regex = new RegExp(pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*"));
+      return regex.test(diff.filename);
+    });
+    return !matchesExclude;
+  });
+  debug(`Filtered to ${filteredDiffs.length} file(s) after pattern matching`);
+  const targets = [];
+  for (const diff of filteredDiffs) {
+    if (diff.status === "removed") {
+      continue;
+    }
+    try {
+      const fileContents = await githubClient.getFileContents(prHeadRef, diff.filename);
+      const changedRanges = getChangedRanges(diff, fileContents.content);
+      if (changedRanges.length === 0) {
+        continue;
+      }
+      const ranges = changedRanges.map((r) => ({
+        start: r.start,
+        end: r.end,
+        type: r.type
+      }));
+      const fileTargets = await analyzeFile(
+        diff.filename,
+        fileContents.content,
+        ranges,
+        prHeadRef,
+        githubClient,
+        config.testDirectory
+      );
+      targets.push(...fileTargets);
+      if (fileTargets.length > 0) {
+        info(`Found ${fileTargets.length} test target(s) in ${diff.filename}`);
+      }
+    } catch (error2) {
+      debug(`Failed to analyze ${diff.filename}: ${error2 instanceof Error ? error2.message : String(error2)}`);
+    }
+  }
+  info(`Extracted ${targets.length} total test target(s)`);
+  return targets;
+}
+
+// src/llm/providers/base.ts
+var BaseLLMProvider = class {
+  constructor(apiKey, model, defaultOptions) {
+    this.apiKey = apiKey;
+    this.model = model;
+    this.defaultOptions = {
+      temperature: defaultOptions?.temperature ?? 0.2,
+      maxTokens: defaultOptions?.maxTokens ?? 4e3,
+      stopSequences: defaultOptions?.stopSequences ?? []
+    };
+  }
+  mergeOptions(options) {
+    return {
+      temperature: options?.temperature ?? this.defaultOptions.temperature,
+      maxTokens: options?.maxTokens ?? this.defaultOptions.maxTokens,
+      stopSequences: options?.stopSequences ?? this.defaultOptions.stopSequences
+    };
+  }
+  validateApiKey() {
+    if (!this.apiKey || this.apiKey.trim().length === 0) {
+      error("LLM API key is required but not provided");
+      throw new Error("LLM API key is required");
+    }
+  }
+  logUsage(usage, operation) {
+    if (usage) {
+      debug(
+        `${operation} usage: ${usage.totalTokens ?? "unknown"} tokens (prompt: ${usage.promptTokens ?? "unknown"}, completion: ${usage.completionTokens ?? "unknown"})`
+      );
+    }
+  }
+};
+
+// src/llm/providers/openai.ts
+var OpenAIProvider = class extends BaseLLMProvider {
+  constructor() {
+    super(...arguments);
+    this.baseUrl = "https://api.openai.com/v1";
+  }
+  async generate(messages, options) {
+    this.validateApiKey();
+    const mergedOptions = this.mergeOptions(options);
+    const requestBody = {
+      model: this.model,
+      messages: messages.map((msg) => ({
+        role: msg.role,
+        content: msg.content
+      })),
+      temperature: mergedOptions.temperature,
+      max_tokens: mergedOptions.maxTokens,
+      ...mergedOptions.stopSequences.length > 0 && { stop: mergedOptions.stopSequences }
+    };
+    debug(`Calling OpenAI API with model: ${this.model}`);
+    try {
+      const response = await fetch(`${this.baseUrl}/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify(requestBody)
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        error(`OpenAI API error: ${response.status} ${response.statusText} - ${errorText}`);
+        throw new Error(`OpenAI API error: ${response.status} ${response.statusText}`);
+      }
+      const data = await response.json();
+      if (!data.choices || data.choices.length === 0) {
+        error("OpenAI API returned no choices");
+        throw new Error("OpenAI API returned no choices");
+      }
+      const content = data.choices[0]?.message?.content ?? "";
+      const usage = data.usage ? {
+        promptTokens: data.usage.prompt_tokens,
+        completionTokens: data.usage.completion_tokens,
+        totalTokens: data.usage.total_tokens
+      } : void 0;
+      this.logUsage(usage, "OpenAI");
+      return {
+        content,
+        usage
+      };
+    } catch (err) {
+      if (err instanceof Error) {
+        error(`OpenAI API request failed: ${err.message}`);
+        throw err;
+      }
+      throw new Error("Unknown error calling OpenAI API");
+    }
+  }
+};
+
+// src/llm/providers/anthropic.ts
+var AnthropicProvider = class extends BaseLLMProvider {
+  constructor() {
+    super(...arguments);
+    this.baseUrl = "https://api.anthropic.com/v1";
+  }
+  async generate(messages, options) {
+    this.validateApiKey();
+    const mergedOptions = this.mergeOptions(options);
+    const systemMessage = messages.find((m) => m.role === "system")?.content ?? "";
+    const conversationMessages = messages.filter((m) => m.role !== "system");
+    const requestBody = {
+      model: this.model,
+      max_tokens: mergedOptions.maxTokens,
+      temperature: mergedOptions.temperature,
+      messages: conversationMessages.map((msg) => ({
+        role: msg.role === "assistant" ? "assistant" : "user",
+        content: msg.content
+      })),
+      ...systemMessage && { system: systemMessage },
+      ...mergedOptions.stopSequences.length > 0 && { stop_sequences: mergedOptions.stopSequences }
+    };
+    debug(`Calling Anthropic API with model: ${this.model}`);
+    try {
+      const response = await fetch(`${this.baseUrl}/messages`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": this.apiKey,
+          "anthropic-version": "2023-06-01"
+        },
+        body: JSON.stringify(requestBody)
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        error(`Anthropic API error: ${response.status} ${response.statusText} - ${errorText}`);
+        throw new Error(`Anthropic API error: ${response.status} ${response.statusText}`);
+      }
+      const data = await response.json();
+      if (!data.content || data.content.length === 0) {
+        error("Anthropic API returned no content");
+        throw new Error("Anthropic API returned no content");
+      }
+      const content = data.content.map((c) => c.text).join("\n");
+      const usage = data.usage ? {
+        promptTokens: data.usage.input_tokens,
+        completionTokens: data.usage.output_tokens,
+        totalTokens: data.usage.input_tokens + data.usage.output_tokens
+      } : void 0;
+      this.logUsage(usage, "Anthropic");
+      return {
+        content,
+        usage
+      };
+    } catch (err) {
+      if (err instanceof Error) {
+        error(`Anthropic API request failed: ${err.message}`);
+        throw err;
+      }
+      throw new Error("Unknown error calling Anthropic API");
+    }
+  }
+};
+
+// src/llm/providers/google.ts
+var GoogleProvider = class extends BaseLLMProvider {
+  constructor() {
+    super(...arguments);
+    this.baseUrl = "https://generativelanguage.googleapis.com/v1beta";
+  }
+  async generate(messages, options) {
+    this.validateApiKey();
+    const mergedOptions = this.mergeOptions(options);
+    const systemInstruction = messages.find((m) => m.role === "system")?.content;
+    const conversationMessages = messages.filter((m) => m.role !== "system");
+    const contents = conversationMessages.map((msg) => ({
+      role: msg.role === "assistant" ? "model" : "user",
+      parts: [{ text: msg.content }]
+    }));
+    const generationConfig = {
+      temperature: mergedOptions.temperature,
+      maxOutputTokens: mergedOptions.maxTokens,
+      ...mergedOptions.stopSequences.length > 0 && { stopSequences: mergedOptions.stopSequences }
+    };
+    const requestBody = {
+      contents,
+      generationConfig,
+      ...systemInstruction && { systemInstruction: { parts: [{ text: systemInstruction }] } }
+    };
+    debug(`Calling Google API with model: ${this.model}`);
+    try {
+      const response = await fetch(`${this.baseUrl}/${this.model}:generateContent?key=${this.apiKey}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(requestBody)
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        error(`Google API error: ${response.status} ${response.statusText} - ${errorText}`);
+        throw new Error(`Google API error: ${response.status} ${response.statusText}`);
+      }
+      const data = await response.json();
+      if (!data.candidates || data.candidates.length === 0) {
+        error("Google API returned no candidates");
+        throw new Error("Google API returned no candidates");
+      }
+      const content = data.candidates[0]?.content?.parts?.map((p) => p.text).join("\n") ?? "";
+      const usage = data.usageMetadata ? {
+        promptTokens: data.usageMetadata.promptTokenCount,
+        completionTokens: data.usageMetadata.candidatesTokenCount,
+        totalTokens: data.usageMetadata.totalTokenCount
+      } : void 0;
+      this.logUsage(usage, "Google");
+      return {
+        content,
+        usage
+      };
+    } catch (err) {
+      if (err instanceof Error) {
+        error(`Google API request failed: ${err.message}`);
+        throw err;
+      }
+      throw new Error("Unknown error calling Google API");
+    }
+  }
+};
+
+// src/llm/factory.ts
+function createLLMProvider(config) {
+  const provider = config.provider ?? "openai";
+  const model = config.model ?? getDefaultModel(provider);
+  const defaultOptions = config.maxTokens ? { maxTokens: config.maxTokens } : void 0;
+  switch (provider) {
+    case "openai":
+      return new OpenAIProvider(config.apiKey, model, defaultOptions);
+    case "anthropic":
+      return new AnthropicProvider(config.apiKey, model, defaultOptions);
+    case "google":
+      return new GoogleProvider(config.apiKey, model, defaultOptions);
+    default:
+      error(`Unknown LLM provider: ${provider}`);
+      throw new Error(`Unknown LLM provider: ${provider}`);
+  }
+}
+function getDefaultModel(provider) {
+  switch (provider) {
+    case "openai":
+      return "gpt-4-turbo-preview";
+    case "anthropic":
+      return "claude-3-5-sonnet-20241022";
+    case "google":
+      return "gemini-1.5-pro";
+    default:
+      return "gpt-4-turbo-preview";
+  }
+}
+
+// src/llm/prompts/test-generation.ts
+function buildTestGenerationPrompt(context) {
+  const { target, framework, existingTestFile, relatedFunctions } = context;
+  const systemPrompt = buildSystemPrompt(framework);
+  const userPrompt = buildUserPrompt(target, framework, existingTestFile, relatedFunctions);
+  return [
+    { role: "system", content: systemPrompt },
+    { role: "user", content: userPrompt }
+  ];
+}
+function buildSystemPrompt(framework) {
+  const frameworkName = framework === "jest" ? "Jest" : "Vitest";
+  const importStatement = framework === "jest" ? "import { describe, it, expect } from 'jest';" : "import { describe, it, expect } from 'vitest';";
+  return `You are an expert ${frameworkName} test writer. Your task is to generate comprehensive unit tests for TypeScript/JavaScript functions.
+
+Requirements:
+1. Generate complete, runnable ${frameworkName} test code
+2. Use ${frameworkName} syntax and best practices
+3. Test edge cases, error conditions, and normal operation
+4. Use descriptive test names that explain what is being tested
+5. Include proper setup/teardown if needed
+6. Mock external dependencies appropriately
+7. Test both success and failure scenarios
+8. Follow the existing test file structure if one exists
+
+Output format:
+- Return ONLY the test code, no explanations or markdown code blocks
+- The code should be ready to run in a ${frameworkName} environment
+- Include necessary imports at the top
+- Use proper TypeScript types if the source code uses TypeScript
+
+${frameworkName} example structure:
+${importStatement}
+
+describe('FunctionName', () => {
+  it('should handle normal case', () => {
+    // test implementation
+  });
+
+  it('should handle edge case', () => {
+    // test implementation
+  });
+});`;
+}
+function buildUserPrompt(target, framework, existingTestFile, relatedFunctions) {
+  let prompt = `Generate ${framework} unit tests for the following function:
+
+`;
+  prompt += `File: ${target.filePath}
+`;
+  prompt += `Function: ${target.functionName}
+`;
+  prompt += `Type: ${target.functionType}
+
+`;
+  prompt += `Function code:
+\`\`\`typescript
+${target.code}
+\`\`\`
+
+`;
+  if (target.context) {
+    prompt += `Context (surrounding code):
+\`\`\`typescript
+${target.context}
+\`\`\`
+
+`;
+  }
+  if (relatedFunctions && relatedFunctions.length > 0) {
+    prompt += `Related functions (for context):
+`;
+    relatedFunctions.forEach((fn) => {
+      prompt += `
+${fn.name}:
+\`\`\`typescript
+${fn.code}
+\`\`\`
+`;
+    });
+    prompt += "\n";
+  }
+  if (existingTestFile) {
+    prompt += `Existing test file structure (follow this pattern):
+\`\`\`typescript
+${existingTestFile}
+\`\`\`
+
+`;
+    prompt += `Note: Add new tests to this file, maintaining the existing structure and style.
+
+`;
+  }
+  prompt += `Generate comprehensive unit tests for ${target.functionName}. Include:
+`;
+  prompt += `- Tests for normal operation with various inputs
+`;
+  prompt += `- Tests for edge cases (null, undefined, empty arrays, etc.)
+`;
+  prompt += `- Tests for error conditions if applicable
+`;
+  prompt += `- Tests for boundary conditions
+`;
+  prompt += `- Proper mocking of dependencies if needed
+
+`;
+  prompt += `Return ONLY the test code, no explanations or markdown formatting.`;
+  return prompt;
+}
+
+// src/llm/prompts/test-fix.ts
+function buildTestFixPrompt(context) {
+  const { testCode, errorMessage, testOutput, originalCode, framework, attempt, maxAttempts } = context;
+  const systemPrompt = buildSystemPrompt2(framework, attempt, maxAttempts);
+  const userPrompt = buildUserPrompt2(testCode, errorMessage, testOutput, originalCode, framework, attempt);
+  return [
+    { role: "system", content: systemPrompt },
+    { role: "user", content: userPrompt }
+  ];
+}
+function buildSystemPrompt2(framework, attempt, maxAttempts) {
+  const frameworkName = framework === "jest" ? "Jest" : "Vitest";
+  return `You are an expert ${frameworkName} test debugger. Your task is to fix failing unit tests.
+
+Context:
+- This is fix attempt ${attempt} of ${maxAttempts}
+- The test code failed to run or produced incorrect results
+- You need to analyze the error and fix the test code
+
+Requirements:
+1. Fix the test code to make it pass
+2. Maintain the original test intent
+3. Use proper ${frameworkName} syntax
+4. Ensure all imports and dependencies are correct
+5. Fix any syntax errors, type errors, or logical errors
+6. If the original code being tested has issues, note that but focus on fixing the test
+
+Output format:
+- Return ONLY the fixed test code, no explanations or markdown code blocks
+- The code should be complete and runnable
+- Include all necessary imports`;
+}
+function buildUserPrompt2(testCode, errorMessage, testOutput, originalCode, framework, attempt) {
+  let prompt = `The following ${framework} test is failing. Fix it:
+
+`;
+  prompt += `Original function code:
+\`\`\`typescript
+${originalCode}
+\`\`\`
+
+`;
+  prompt += `Failing test code:
+\`\`\`typescript
+${testCode}
+\`\`\`
+
+`;
+  prompt += `Error message:
+\`\`\`
+${errorMessage}
+\`\`\`
+
+`;
+  if (testOutput) {
+    prompt += `Test output:
+\`\`\`
+${testOutput}
+\`\`\`
+
+`;
+  }
+  if (attempt > 1) {
+    prompt += `Note: This is fix attempt ${attempt}. Previous attempts failed. Please analyze the error more carefully.
+
+`;
+  }
+  prompt += `Fix the test code to resolve the error. Return ONLY the corrected test code, no explanations.`;
+  return prompt;
+}
+
+// src/llm/parser.ts
+function parseTestCode(response) {
+  let code = response.trim();
+  const codeBlockRegex = /^```(?:typescript|ts|javascript|js)?\s*\n([\s\S]*?)\n```$/;
+  const match = code.match(codeBlockRegex);
+  if (match) {
+    code = match[1].trim();
+  } else {
+    const inlineCodeRegex = /```([\s\S]*?)```/g;
+    const inlineMatches = Array.from(code.matchAll(inlineCodeRegex));
+    if (inlineMatches.length > 0) {
+      code = inlineMatches.reduce((largest, match2) => {
+        return match2[1].length > largest.length ? match2[1] : largest;
+      }, "");
+      code = code.trim();
+    }
+  }
+  const explanationPatterns = [
+    /^Here'?s?\s+(?:the\s+)?(?:test\s+)?code:?\s*/i,
+    /^Test\s+code:?\s*/i,
+    /^Generated\s+test:?\s*/i,
+    /^Here\s+is\s+the\s+test:?\s*/i
+  ];
+  for (const pattern of explanationPatterns) {
+    if (pattern.test(code)) {
+      code = code.replace(pattern, "").trim();
+      const codeBlockMatch = code.match(/```[\s\S]*?```/);
+      if (codeBlockMatch) {
+        code = codeBlockMatch[0];
+        code = code.replace(/^```(?:typescript|ts|javascript|js)?\s*\n?/, "").replace(/\n?```$/, "").trim();
+      }
+    }
+  }
+  code = code.replace(/^```[\w]*\n?/, "").replace(/\n?```$/, "").trim();
+  if (!code) {
+    warn("Failed to extract test code from LLM response");
+    return response;
+  }
+  return code;
+}
+function validateTestCodeStructure(code, framework) {
+  const errors = [];
+  if (!code.includes("describe") && !code.includes("it(") && !code.includes("test(")) {
+    errors.push("Missing test structure (describe/it/test)");
+  }
+  if (framework === "jest") {
+    if (!code.includes("from 'jest'") && !code.includes('from "jest"') && !code.includes("require(")) {
+      if (!code.includes("describe") && !code.includes("it") && !code.includes("test")) {
+        errors.push("Missing Jest test functions");
+      }
+    }
+  } else if (framework === "vitest") {
+    if (!code.includes("from 'vitest'") && !code.includes('from "vitest"')) {
+      errors.push("Missing Vitest import");
+    }
+  }
+  if (code.trim().length < 20) {
+    errors.push("Test code appears too short or empty");
+  }
+  if (!code.match(/(describe|it|test)\s*\(/)) {
+    errors.push("Missing test function calls (describe/it/test)");
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+// src/llm/test-generator.ts
+var TestGenerator = class {
+  constructor(config) {
+    this.provider = createLLMProvider(config);
+    this.config = {
+      maxFixAttempts: config.maxFixAttempts,
+      temperature: config.temperature,
+      fixTemperature: config.fixTemperature
+    };
+  }
+  /**
+   * Generate test code for a test target
+   */
+  async generateTest(context) {
+    const { target, framework } = context;
+    info(`Generating ${framework} tests for ${target.functionName} in ${target.filePath}`);
+    try {
+      const messages = buildTestGenerationPrompt(context);
+      debug(`Sending test generation request to LLM for ${target.functionName}`);
+      const response = await this.provider.generate(messages, {
+        temperature: this.config.temperature ?? 0.2,
+        // Lower temperature for more consistent test generation
+        maxTokens: 4e3
+      });
+      const testCode = parseTestCode(response.content);
+      const validation = validateTestCodeStructure(testCode, framework);
+      if (!validation.valid) {
+        warn(`Test code validation warnings for ${target.functionName}: ${validation.errors.join(", ")}`);
+      }
+      debug(`Successfully generated test code for ${target.functionName}`);
+      return {
+        testCode,
+        explanation: response.content !== testCode ? "Code extracted from LLM response" : void 0,
+        usage: response.usage
+      };
+    } catch (err) {
+      error(`Failed to generate test for ${target.functionName}: ${err instanceof Error ? err.message : String(err)}`);
+      throw err;
+    }
+  }
+  /**
+   * Fix a failing test by generating a corrected version
+   */
+  async fixTest(context) {
+    const { framework, attempt } = context;
+    info(`Fixing test (attempt ${attempt}/${this.config.maxFixAttempts})`);
+    try {
+      const messages = buildTestFixPrompt(context);
+      debug(`Sending test fix request to LLM (attempt ${attempt})`);
+      const response = await this.provider.generate(messages, {
+        temperature: this.config.fixTemperature ?? 0.1,
+        // Very low temperature for fix attempts
+        maxTokens: 4e3
+      });
+      const fixedCode = parseTestCode(response.content);
+      const validation = validateTestCodeStructure(fixedCode, framework);
+      if (!validation.valid) {
+        warn(`Fixed test code validation warnings: ${validation.errors.join(", ")}`);
+      }
+      debug(`Successfully generated fixed test code (attempt ${attempt})`);
+      return {
+        testCode: fixedCode,
+        explanation: `Fixed test code (attempt ${attempt})`,
+        usage: response.usage
+      };
+    } catch (err) {
+      error(`Failed to fix test (attempt ${attempt}): ${err instanceof Error ? err.message : String(err)}`);
+      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/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/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)}`);
+  }
+}
+
+// src/cli/index.ts
+function parseRepository(repo) {
+  const parts = repo.split("/");
+  if (parts.length !== 2) {
+    throw new Error(`Invalid repository format: ${repo}. Expected "owner/repo"`);
+  }
+  return { owner: parts[0], repo: parts[1] };
+}
+async function detectGitRepository(projectRoot) {
+  try {
+    const git = simpleGit(projectRoot);
+    let remoteUrl = null;
+    try {
+      remoteUrl = await git.getRemotes(true).then((remotes) => {
+        const origin = remotes.find((r) => r.name === "origin");
+        return origin?.refs?.fetch || origin?.refs?.push || null;
+      });
+      if (!remoteUrl) {
+        const remotes = await git.getRemotes(true);
+        if (remotes.length > 0) {
+          remoteUrl = remotes[0].refs?.fetch || remotes[0].refs?.push || null;
+        }
+      }
+    } catch {
+      return null;
+    }
+    if (!remoteUrl) {
+      return null;
+    }
+    try {
+      const parsed = gitUrlParse(remoteUrl);
+      if (parsed.resource === "github.com") {
+        return {
+          owner: parsed.owner,
+          repo: parsed.name.replace(/\.git$/, "")
+        };
+      }
+    } catch {
+      return null;
+    }
+    return null;
+  } catch (err) {
+    debug(`Failed to detect git repository: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+}
+function extractPRNumber(eventPath) {
+  if (!eventPath) {
+    return null;
+  }
+  try {
+    const eventContent = readFileSync2(eventPath, "utf-8");
+    const event = JSON.parse(eventContent);
+    if (event.pull_request?.number) {
+      return event.pull_request.number;
+    }
+    if (event.number) {
+      return event.number;
+    }
+    return null;
+  } catch (err) {
+    error(`Failed to read GitHub event file: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+}
+async function main() {
+  const program = new Command();
+  program.name("kakarot-ci").description("AI-powered unit test generation for pull requests").version("0.2.0").option("--pr <number>", "Pull request number").option("--owner <string>", "Repository owner").option("--repo <string>", "Repository name").option("--token <string>", "GitHub token (or use GITHUB_TOKEN env var)").parse(process.argv);
+  const options = program.opts();
+  let config;
+  try {
+    config = await loadConfig();
+  } catch (err) {
+    config = null;
+  }
+  const githubRepository = process.env.GITHUB_REPOSITORY;
+  const githubEventPath = process.env.GITHUB_EVENT_PATH;
+  const githubToken = options.token || config?.githubToken || process.env.GITHUB_TOKEN;
+  const prNumberEnv = process.env.PR_NUMBER;
+  let owner = options.owner;
+  let repo = options.repo;
+  if (!owner || !repo) {
+    if (githubRepository) {
+      try {
+        const parsed = parseRepository(githubRepository);
+        owner = owner || parsed.owner;
+        repo = repo || parsed.repo;
+      } catch (err) {
+        if (!owner && !repo) {
+          error(err instanceof Error ? err.message : String(err));
+          process.exit(1);
+        }
+      }
+    }
+  }
+  if (!owner || !repo) {
+    owner = owner || config?.githubOwner;
+    repo = repo || config?.githubRepo;
+  }
+  if (!owner || !repo) {
+    const projectRoot = await findProjectRoot();
+    const gitRepo = await detectGitRepository(projectRoot);
+    if (gitRepo) {
+      owner = owner || gitRepo.owner;
+      repo = repo || gitRepo.repo;
+      debug(`Detected repository from git: ${owner}/${repo}`);
+    }
+  }
+  if (!owner || !repo) {
+    error("Repository owner and name are required.");
+    error("Provide via:");
+    error("  - Config file: githubOwner and githubRepo");
+    error("  - CLI flags: --owner and --repo");
+    error('  - Environment: GITHUB_REPOSITORY (format: "owner/repo")');
+    error("  - Git remote: auto-detected from current repository");
+    process.exit(1);
+  }
+  if (!githubToken) {
+    error("GitHub token is required.");
+    error("Provide via:");
+    error("  - Config file: githubToken");
+    error("  - CLI flag: --token");
+    error("  - Environment: GITHUB_TOKEN");
+    process.exit(1);
+  }
+  let prNumber = null;
+  if (options.pr) {
+    prNumber = parseInt(String(options.pr), 10);
+    if (isNaN(prNumber)) {
+      error(`Invalid PR number: ${options.pr}`);
+      process.exit(1);
+    }
+  } else if (prNumberEnv) {
+    const parsed = parseInt(prNumberEnv, 10);
+    if (!isNaN(parsed)) {
+      prNumber = parsed;
+    }
+  } else if (githubEventPath) {
+    prNumber = extractPRNumber(githubEventPath);
+  }
+  if (!prNumber) {
+    error("Pull request number is required.");
+    error("Provide via:");
+    error("  - CLI flag: --pr <number>");
+    error("  - Environment: PR_NUMBER");
+    error("  - GitHub Actions: GITHUB_EVENT_PATH (auto-detected)");
+    process.exit(1);
+  }
+  const context = {
+    prNumber,
+    owner,
+    repo,
+    githubToken
+  };
+  info(`Starting Kakarot CI for PR #${prNumber} in ${owner}/${repo}`);
+  try {
+    const summary = await runPullRequest(context);
+    if (summary.errors.length > 0 || summary.testsFailed > 0) {
+      error(`Test generation completed with errors: ${summary.errors.length} error(s), ${summary.testsFailed} test(s) failed`);
+      process.exit(1);
+    }
+    info(`Test generation completed successfully: ${summary.testsGenerated} test(s) generated`);
+    process.exit(0);
+  } catch (err) {
+    error(`Fatal error: ${err instanceof Error ? err.message : String(err)}`);
+    if (err instanceof Error && err.stack) {
+      error(err.stack);
+    }
+    process.exit(1);
+  }
+}
+main().catch((err) => {
+  error(`Unhandled error: ${err instanceof Error ? err.message : String(err)}`);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map