ai-test-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1789 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/core/logger.ts
+import chalk from "chalk";
+import ora from "ora";
+var logger;
+var init_logger = __esm({
+  "src/core/logger.ts"() {
+    "use strict";
+    logger = {
+      info: (msg) => console.log(chalk.blue("\u2139"), msg),
+      success: (msg) => console.log(chalk.green("\u2714"), msg),
+      error: (msg) => console.error(chalk.red("\u2716"), msg),
+      warn: (msg) => console.warn(chalk.yellow("\u26A0"), msg),
+      log: (msg) => console.log(msg),
+      spinner: (text) => ora(text)
+    };
+  }
+});
+
+// src/core/config.ts
+import { cosmiconfig } from "cosmiconfig";
+import { writeFile } from "fs/promises";
+import { resolve } from "path";
+async function loadConfig() {
+  try {
+    const result = await explorer.search();
+    if (result) {
+      return result.config;
+    }
+    return null;
+  } catch (error) {
+    logger.error(`Failed to load config: ${error}`);
+    return null;
+  }
+}
+async function saveConfig(config2, targetDir = process.cwd()) {
+  const configPath = resolve(targetDir, ".aitestrc.json");
+  try {
+    await writeFile(configPath, JSON.stringify(config2, null, 2), "utf-8");
+    logger.success(`Saved config to ${configPath}`);
+  } catch (error) {
+    logger.error(`Failed to save config: ${error}`);
+    throw error;
+  }
+}
+var moduleName, explorer;
+var init_config = __esm({
+  "src/core/config.ts"() {
+    "use strict";
+    init_logger();
+    moduleName = "aitest";
+    explorer = cosmiconfig(moduleName);
+  }
+});
+
+// src/core/detector.ts
+import { readFileSync, existsSync } from "fs";
+import { resolve as resolve2 } from "path";
+function detectProjectInfo(targetDir = process.cwd()) {
+  const packageJsonPath = resolve2(targetDir, "package.json");
+  const tsconfigPath = resolve2(targetDir, "tsconfig.json");
+  let packageJson2 = {};
+  if (existsSync(packageJsonPath)) {
+    try {
+      packageJson2 = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    } catch (e) {
+    }
+  }
+  const allDeps = {
+    ...packageJson2.dependencies || {},
+    ...packageJson2.devDependencies || {}
+  };
+  const language = existsSync(tsconfigPath) || allDeps["typescript"] ? "typescript" : "javascript";
+  let testRunner = "unknown";
+  if (allDeps["jest"]) testRunner = "jest";
+  else if (allDeps["vitest"]) testRunner = "vitest";
+  else if (allDeps["mocha"]) testRunner = "mocha";
+  let framework = "unknown";
+  if (allDeps["react"]) framework = "react";
+  else if (allDeps["vue"]) framework = "vue";
+  else if (allDeps["@angular/core"]) framework = "angular";
+  else if (allDeps["express"] || allDeps["@nestjs/core"] || allDeps["fastify"]) framework = "node";
+  let packageManager = "npm";
+  if (existsSync(resolve2(targetDir, "pnpm-lock.yaml"))) packageManager = "pnpm";
+  else if (existsSync(resolve2(targetDir, "yarn.lock"))) packageManager = "yarn";
+  else if (existsSync(resolve2(targetDir, "bun.lockb"))) packageManager = "bun";
+  return { language, testRunner, framework, packageManager };
+}
+var init_detector = __esm({
+  "src/core/detector.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/ai.ts
+import { generateText } from "ai";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { createDeepSeek } from "@ai-sdk/deepseek";
+import * as dotenv from "dotenv";
+function getAIModel(config2) {
+  const providerName = config2.provider.toLowerCase();
+  if (providerName === "openai") {
+    const openai = createOpenAI({
+      apiKey: config2.apiKey || process.env.OPENAI_API_KEY
+    });
+    return openai(config2.model || "gpt-4o");
+  }
+  if (providerName === "anthropic") {
+    const anthropic = createAnthropic({
+      apiKey: config2.apiKey || process.env.ANTHROPIC_API_KEY
+    });
+    return anthropic(config2.model || "claude-3-5-sonnet-20240620");
+  }
+  if (providerName === "gemini" || providerName === "google") {
+    const google = createGoogleGenerativeAI({
+      apiKey: config2.apiKey || process.env.GEMINI_API_KEY || process.env.GOOGLE_GENERATIVE_AI_API_KEY
+    });
+    return google(config2.model || "gemini-2.5-flash");
+  }
+  if (providerName === "deepseek") {
+    const deepseek = createDeepSeek({
+      apiKey: config2.apiKey || process.env.DEEPSEEK_API_KEY
+    });
+    return deepseek(config2.model || "deepseek-coder");
+  }
+  if (providerName === "ollama") {
+    const ollama = createOpenAI({
+      baseURL: "http://localhost:11434/v1",
+      apiKey: "ollama"
+      // API key isn't strictly needed for local Ollama
+    });
+    return ollama(config2.model || "llama3.1");
+  }
+  if (providerName === "custom") {
+    const custom = createOpenAI({
+      baseURL: config2.baseURL,
+      apiKey: config2.apiKey || process.env.CUSTOM_API_KEY || "custom",
+      headers: config2.customHeaders
+    });
+    return custom(config2.model || "local-model");
+  }
+  throw new Error(`Unsupported AI provider: ${config2.provider}`);
+}
+async function askAI(config2, system, prompt) {
+  const model = getAIModel(config2);
+  const { text } = await generateText({
+    model,
+    system,
+    prompt,
+    maxRetries: 5,
+    temperature: config2.temperature || 0.1
+  });
+  return text;
+}
+var init_ai = __esm({
+  "src/core/ai.ts"() {
+    "use strict";
+    dotenv.config();
+  }
+});
+
+// src/core/scanner.ts
+var scanner_exports = {};
+__export(scanner_exports, {
+  generateWorkspaceMap: () => generateWorkspaceMap,
+  scanDependencies: () => scanDependencies
+});
+import { Project } from "ts-morph";
+import { existsSync as existsSync3, readFileSync as readFileSync5, statSync } from "fs";
+import { resolve as resolve6, dirname } from "path";
+import fg2 from "fast-glob";
+function resolveLocalPath(baseDir, moduleSpecifier) {
+  let cleanedSpecifier = moduleSpecifier;
+  if (cleanedSpecifier.endsWith(".js")) {
+    cleanedSpecifier = cleanedSpecifier.replace(/\.js$/, "");
+  }
+  const exts = [".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.js", "/index.tsx", "/index.jsx"];
+  const fullPath = resolve6(baseDir, cleanedSpecifier);
+  try {
+    const exactPath = resolve6(baseDir, moduleSpecifier);
+    if (existsSync3(exactPath) && statSync(exactPath).isFile()) {
+      return exactPath;
+    }
+  } catch (e) {
+  }
+  for (const ext of exts) {
+    const withExt = fullPath + ext;
+    try {
+      if (existsSync3(withExt) && statSync(withExt).isFile()) {
+        return withExt;
+      }
+    } catch (e) {
+    }
+  }
+  return null;
+}
+function scanDependencies(filePath, maxTokens = 2e3) {
+  try {
+    const project = new Project();
+    const sourceFile = project.addSourceFileAtPath(filePath);
+    let context = "";
+    const imports = sourceFile.getImportDeclarations();
+    const baseDir = dirname(filePath);
+    for (const imp of imports) {
+      const moduleSpecifier = imp.getModuleSpecifierValue();
+      if (!moduleSpecifier.startsWith(".") && !moduleSpecifier.startsWith("/")) {
+        continue;
+      }
+      const resolvedPath = resolveLocalPath(baseDir, moduleSpecifier);
+      if (resolvedPath) {
+        const content = readFileSync5(resolvedPath, "utf-8");
+        context += `
+--- Related Context from ${moduleSpecifier} ---
+${content}
+`;
+        if (context.length > maxTokens * 4) {
+          context = context.substring(0, maxTokens * 4) + "\n... [Context Truncated due to size limits]";
+          break;
+        }
+      }
+    }
+    const possiblePrismaPaths = [
+      resolve6(process.cwd(), "prisma/schema.prisma"),
+      resolve6(process.cwd(), "schema.prisma")
+    ];
+    for (const p of possiblePrismaPaths) {
+      if (existsSync3(p)) {
+        const content = readFileSync5(p, "utf-8");
+        context += `
+--- Prisma Schema Context ---
+${content}
+`;
+        break;
+      }
+    }
+    return context.trim();
+  } catch (error) {
+    logger.error(`Architecture Scanner failed for ${filePath}: ${error.message}`);
+    return "";
+  }
+}
+async function generateWorkspaceMap() {
+  try {
+    const files = await fg2([
+      "**/*.{ts,js,tsx,jsx,json,prisma}",
+      "!**/node_modules/**",
+      "!**/dist/**",
+      "!**/build/**",
+      "!**/coverage/**"
+    ], { cwd: process.cwd(), dot: true });
+    let mapStr = files.join("\n");
+    if (mapStr.length > 5e3) {
+      mapStr = mapStr.substring(0, 5e3) + "\n\n... [WORKSPACE MAP TRUNCATED DUE TO SIZE LIMIT].\nWARNING: The repository is too large to fit in this prompt. Use your `list_dir` tool to explore directories to find the exact file paths you need.";
+    }
+    return mapStr;
+  } catch (error) {
+    return "";
+  }
+}
+var init_scanner = __esm({
+  "src/core/scanner.ts"() {
+    "use strict";
+    init_logger();
+  }
+});
+
+// src/core/runner.ts
+import { exec as exec4 } from "child_process";
+import { promisify as promisify4 } from "util";
+async function runSingleTest(testFilePath, projectInfo) {
+  let command = `npm test -- "${testFilePath}"`;
+  if (projectInfo.testRunner === "jest") {
+    command = `npx jest "${testFilePath}" --forceExit`;
+  } else if (projectInfo.testRunner === "vitest") {
+    command = `npx vitest run "${testFilePath}"`;
+  } else if (projectInfo.testRunner === "mocha") {
+    command = `npx mocha "${testFilePath}" --exit`;
+  }
+  try {
+    const { stdout, stderr } = await execAsync4(command, { cwd: process.cwd() });
+    return {
+      passed: true,
+      output: `${stdout}
+${stderr}`.trim()
+    };
+  } catch (error) {
+    return {
+      passed: false,
+      output: `${error.stdout || ""}
+${error.stderr || ""}
+${error.message || ""}`.trim()
+    };
+  }
+}
+var execAsync4;
+var init_runner = __esm({
+  "src/core/runner.ts"() {
+    "use strict";
+    execAsync4 = promisify4(exec4);
+  }
+});
+
+// src/core/agentic.ts
+import { exec as exec5 } from "child_process";
+import { promisify as promisify5 } from "util";
+import { writeFileSync as writeFileSync3, readFileSync as readFileSync6, existsSync as existsSync4, readdirSync } from "fs";
+import { resolve as resolve7, dirname as dirname2 } from "path";
+import chalk2 from "chalk";
+var execAsync5, AgenticPlanner;
+var init_agentic = __esm({
+  "src/core/agentic.ts"() {
+    "use strict";
+    init_ai();
+    init_runner();
+    init_generate();
+    execAsync5 = promisify5(exec5);
+    AgenticPlanner = class {
+      constructor(config2, projectInfo, workspaceMap = "") {
+        this.config = config2;
+        this.projectInfo = projectInfo;
+        this.workspaceMap = workspaceMap;
+      }
+      config;
+      projectInfo;
+      workspaceMap;
+      /** Detect if the AI provider is a cloud provider with a massive context window */
+      _isCloudProvider() {
+        const p = (this.config.provider || "").toLowerCase();
+        return p.includes("deepseek") || p.includes("openai") || p.includes("anthropic") || p.includes("gemini") || p.includes("google");
+      }
+      /** Generate tests for a file using the LLM planning loop. */
+      async generateFile(sourceFilePath, options = {}) {
+        const { forceUpdate = false, evaluateExisting = false } = options;
+        let isMassive = false;
+        let fileLength = 0;
+        try {
+          const content = readFileSync6(sourceFilePath, "utf-8");
+          fileLength = content.length;
+          isMassive = fileLength > 2e4;
+        } catch (e) {
+        }
+        let initialResult = "failed";
+        if (isMassive) {
+          console.log(chalk2.yellow(`
+\u26A0 File ${sourceFilePath.split("/").pop()} is massive (${fileLength} chars). Engaging Agentic Chunking Generator...`));
+          initialResult = await this._runAgenticGeneratorLoop(sourceFilePath, this._deriveTestPath(sourceFilePath));
+        } else {
+          initialResult = await generateTestForFile(
+            sourceFilePath,
+            this.config,
+            this.projectInfo,
+            forceUpdate,
+            evaluateExisting,
+            this.workspaceMap
+          );
+        }
+        if (initialResult === "skipped") return "skipped";
+        if (initialResult === "failed") return "failed";
+        return this._runAgenticLoop(this._deriveTestPath(sourceFilePath), sourceFilePath);
+      }
+      /** Run the agentic repair loop on an existing test file. */
+      async fixTestFile(testFilePath, sourceFilePath) {
+        return this._runAgenticLoop(testFilePath, sourceFilePath);
+      }
+      async _runAgenticGeneratorLoop(sourceFilePath, testFilePath) {
+        let attempts = 0;
+        const maxAttempts = 50;
+        let stagnationCounter = 0;
+        let previousStepsHash = "";
+        let duplicateCount = 0;
+        let testCode = "";
+        const history = [];
+        let fileLines = [];
+        try {
+          fileLines = readFileSync6(sourceFilePath, "utf-8").split("\n");
+        } catch (e) {
+          return "failed";
+        }
+        if (existsSync4(testFilePath)) {
+          testCode = readFileSync6(testFilePath, "utf-8");
+        } else {
+          writeFileSync3(testFilePath, testCode, "utf-8");
+        }
+        console.log(chalk2.blue(`\u2139 Starting Agentic Chunking Generator for ${sourceFilePath.split("/").pop()} (${fileLines.length} lines)...`));
+        while (attempts < maxAttempts) {
+          attempts++;
+          const plan = await this._requestGenPlan(testCode, testFilePath, sourceFilePath, fileLines.length, history);
+          if (!plan) {
+            console.log(chalk2.red(`\u2716 AI failed to generate a valid generation plan.`));
+            return "failed";
+          }
+          const currentStepsHash = JSON.stringify(plan.steps);
+          if (currentStepsHash === previousStepsHash) {
+            duplicateCount++;
+            if (duplicateCount >= 3) {
+              console.log(chalk2.red(`\u2716 AI generated the exact same action 3 times in a row. Forcibly breaking loop.`));
+              break;
+            }
+          } else {
+            duplicateCount = 0;
+            previousStepsHash = currentStepsHash;
+          }
+          console.log(chalk2.cyan(`\u{1F916} AI Generator returned a plan:
+  \u{1F914} Reasoning: ${plan.reasoning}`));
+          let isFinished = false;
+          let madeProgress = false;
+          for (const step of plan.steps) {
+            if (step.action === "read_lines") {
+              console.log(chalk2.cyan(`  - \u{1F4D6} Reading lines ${step.start} to ${step.end}`));
+              const startIdx = Math.max(0, step.start - 1);
+              const endIdx = Math.min(fileLines.length, step.end);
+              const chunk = fileLines.slice(startIdx, endIdx).map((l, i) => `${startIdx + i + 1}: ${l}`).join("\n");
+              history.push(`Attempt ${attempts}: Read lines ${step.start}-${step.end}:
+${chunk}`);
+            } else if (step.action === "search_file") {
+              console.log(chalk2.cyan(`  - \u{1F50D} Searching for "${step.query}"`));
+              const matches = fileLines.map((line, idx) => ({ line, idx: idx + 1 })).filter(({ line }) => line.includes(step.query)).slice(0, 30);
+              const matchStr = matches.length > 0 ? matches.map((m) => `Line ${m.idx}: ${m.line}`).join("\n") : "No matches found.";
+              history.push(`Attempt ${attempts}: Searched for "${step.query}". Results:
+${matchStr}`);
+            } else if (step.action === "append_test") {
+              console.log(chalk2.cyan(`  - \u{1F4DD} Appending test code chunk`));
+              testCode += "\n" + step.code;
+              writeFileSync3(testFilePath, testCode, "utf-8");
+              history.push(`Attempt ${attempts}: Appended test code.`);
+              madeProgress = true;
+            } else if (step.action === "finish") {
+              console.log(chalk2.green(`  - \u2705 AI finished generating the test file.`));
+              history.push(`Attempt ${attempts}: Finished. Reason: ${step.reason}`);
+              isFinished = true;
+            }
+          }
+          if (isFinished) {
+            return "generated";
+          }
+          if (madeProgress) {
+            stagnationCounter = 0;
+          } else {
+            stagnationCounter++;
+          }
+          if (stagnationCounter >= 10) {
+            console.log(chalk2.red(`
+\u2716 AI exhausted 10 exploration attempts without making progress. Forcibly breaking loop.`));
+            break;
+          }
+          await new Promise((r) => setTimeout(r, 500));
+        }
+        if (attempts >= maxAttempts) {
+          console.log(chalk2.yellow(`
+\u26A0 Reached maximum limit of ${maxAttempts} attempts. Safe breaking. To continue generating coverage, run the command again.`));
+        }
+        return testCode.trim().length > 0 ? "generated" : "failed";
+      }
+      async _requestGenPlan(testCode, testFilePath, sourceFilePath, totalLines, history) {
+        const historyContext = history.length > 0 ? `
+--- PREVIOUS ACTIONS & RESULTS ---
+${history.join("\n\n")}
+` : "";
+        const testFramework = this.projectInfo.testRunner === "unknown" ? "Jest" : this.projectInfo.testRunner;
+        const isCloud = this._isCloudProvider();
+        const testLines = testCode.split("\n");
+        let testContext = "";
+        if (!isCloud && testLines.length > 500) {
+          const topLines = testLines.slice(0, 50).map((l, i) => `${i + 1}: ${l}`).join("\n");
+          const bottomLines = testLines.slice(-200).map((l, i) => `${testLines.length - 200 + i + 1}: ${l}`).join("\n");
+          testContext = `
+--- CURRENT TEST FILE PROGRESS (${testFilePath}) ---
+${topLines}
+... [${testLines.length - 250} lines omitted for Local LLM context support] ...
+${bottomLines}`;
+        } else {
+          const testCodeWithLines = testLines.map((l, i) => `${i + 1}: ${l}`).join("\n");
+          testContext = `
+--- CURRENT TEST FILE PROGRESS (${testFilePath}) ---
+${testCodeWithLines || "(Empty)"}`;
+        }
+        const prompt = `You are an expert QA engineer building a test suite for a massive file using an interactive chunking agent.
+--- TARGET FILE INFO ---
+File: ${sourceFilePath}
+Total Lines: ${totalLines}
+Test Framework: ${testFramework}
+${testContext}
+${historyContext}
+Your goal is to explore the target file chunk-by-chunk and incrementally build the test suite by appending test blocks.
+Based on the current progress, suggest ONE JSON plan describing your next steps. You can combine multiple actions in one plan.
+The JSON must follow this exact schema:
+{
+  "reasoning": "<explain what you are looking for or writing>",
+  "steps": [
+    { "action": "search_file", "query": "<string to search for, e.g. 'export function'>" }
+    | { "action": "read_lines", "start": <line number>, "end": <line number> }
+    | { "action": "append_test", "code": "<valid javascript/typescript test code block to append>" }
+    | { "action": "finish", "reason": "<explanation of completion>" }
+  ]
+}
+
+CRITICAL RULES:
+1. Do NOT wrap the JSON in markdown blocks. Output ONLY raw JSON.
+2. If you don't know where the functions are, use \`search_file\` with queries like "class ", "function ", or "module.exports" to find line numbers.
+3. Once you know the line numbers, use \`read_lines\` to read the implementation of a specific function (max 300 lines at a time).
+4. After reading the implementation, use \`append_test\` to write the test case(s) for that specific function.
+5. If using \`append_test\`, ensure the code is a complete block (e.g. \`describe('...', () => { ... })\`).
+6. When you have tested all major functions, use \`finish\`.`;
+        try {
+          const raw = await askAI(this.config, "Generate a JSON plan for incremental test generation.", prompt);
+          const cleaned = raw.replace(/```json/g, "").replace(/```/g, "").trim();
+          const match = cleaned.match(/\{[\s\S]*\}/);
+          if (!match) return null;
+          return JSON.parse(match[0]);
+        } catch (error) {
+          console.log(chalk2.red(`
+\u2716 AI generator request failed: ${error.message || error}`));
+          return null;
+        }
+      }
+      /** Core agentic reasoning loop for generating and fixing tests. */
+      async _runAgenticLoop(testFilePath, sourceFilePath) {
+        let attempts = 0;
+        const maxAttempts = this.config.maxRetries !== void 0 ? this.config.maxRetries : 3;
+        let lastError = "";
+        let testCode = readFileSync6(testFilePath, "utf-8");
+        const history = [];
+        const recentPatches = [];
+        const fileLabel = sourceFilePath ? sourceFilePath.split("/").pop() : testFilePath.split("/").pop();
+        while (maxAttempts === -1 || attempts < maxAttempts) {
+          attempts++;
+          const result = await runSingleTest(testFilePath, this.projectInfo);
+          if (result.passed) {
+            if (attempts > 1) {
+              console.log(chalk2.green(`
+\u2714 AI successfully fixed the test for ${fileLabel} after ${attempts - 1} attempt(s)!`));
+            } else {
+              console.log(chalk2.green(`
+\u2714 Test ${fileLabel} passed successfully in isolation. No AI fixes were needed!`));
+            }
+            return "generated";
+          }
+          lastError = result.output;
+          const maxText = maxAttempts === -1 ? "\u221E" : maxAttempts;
+          console.log(chalk2.yellow(`
+\u26A0 Test failed for ${fileLabel}. Requesting fix from AI (Attempt ${attempts} of ${maxText})...`));
+          const snippet = lastError.split("\n").slice(0, 15).join("\n");
+          console.log(chalk2.dim(`  Error Snippet:
+    ${snippet.replace(/\n/g, "\n    ")}`));
+          let explorationContext = "";
+          let explorationAttempts = 0;
+          let planExecuted = false;
+          let previousStepsHash = "";
+          let duplicateCount = 0;
+          while (explorationAttempts < 5 && !planExecuted) {
+            explorationAttempts++;
+            const plan = await this._requestPlan(lastError, testCode, testFilePath, history, sourceFilePath, explorationContext);
+            if (!plan) {
+              console.log(chalk2.red(`\u2716 AI failed to generate a valid plan. Giving up on this file.`));
+              return "failed";
+            }
+            const currentStepsHash = JSON.stringify(plan.steps);
+            if (currentStepsHash === previousStepsHash) {
+              duplicateCount++;
+              if (duplicateCount >= 2) {
+                console.log(chalk2.red(`\u2716 AI generated the exact same exploration action consecutively. Forcibly breaking loop.`));
+                break;
+              }
+            } else {
+              duplicateCount = 0;
+              previousStepsHash = currentStepsHash;
+            }
+            console.log(chalk2.cyan(`\u{1F916} AI returned a plan:`));
+            if (plan.reasoning) {
+              console.log(chalk2.gray(`  \u{1F914} Reasoning: ${plan.reasoning}`));
+            }
+            let needsToBreakAndRunTests = false;
+            for (const step of plan.steps) {
+              if (step.action === "read_file") {
+                console.log(chalk2.cyan(`  - \u{1F4D6} Reading file: ${step.path}`));
+                try {
+                  const content = readFileSync6(resolve7(process.cwd(), step.path), "utf-8");
+                  explorationContext += `
+--- READ FILE: ${step.path} ---
+${content}
+`;
+                  history.push(`Attempt ${attempts} (Exploration ${explorationAttempts}): Read file ${step.path}`);
+                } catch (err) {
+                  explorationContext += `
+--- FAILED TO READ FILE: ${step.path} ---
+Error: ${err.message}
+`;
+                  history.push(`Attempt ${attempts} (Exploration ${explorationAttempts}): Failed to read file ${step.path}`);
+                }
+              } else if (step.action === "search_file") {
+                console.log(chalk2.cyan(`  - \u{1F50D} Searching for "${step.query}" in ${step.file}`));
+                try {
+                  const content = readFileSync6(resolve7(process.cwd(), step.file), "utf-8");
+                  const matches = content.split("\n").map((line, idx) => ({ line, idx: idx + 1 })).filter(({ line }) => line.includes(step.query)).slice(0, 30);
+                  const matchStr = matches.length > 0 ? matches.map((m) => `Line ${m.idx}: ${m.line}`).join("\n") : "No matches found.";
+                  explorationContext += `
+--- SEARCH RESULTS FOR "${step.query}" IN ${step.file} ---
+${matchStr}
+`;
+                  history.push(`Attempt ${attempts} (Exploration ${explorationAttempts}): Searched for "${step.query}" in ${step.file}`);
+                } catch (err) {
+                  explorationContext += `
+--- FAILED TO SEARCH FILE: ${step.file} ---
+Error: ${err.message}
+`;
+                  history.push(`Attempt ${attempts} (Exploration ${explorationAttempts}): Failed to search file ${step.file}`);
+                }
+              } else if (step.action === "read_lines") {
+                console.log(chalk2.cyan(`  - \u{1F4D6} Reading lines ${step.startLine}-${step.endLine} from ${step.file}`));
+                try {
+                  const content = readFileSync6(resolve7(process.cwd(), step.file), "utf-8");
+                  const lines = content.split("\n");
+                  const startIdx = Math.max(0, step.startLine - 1);
+                  const endIdx = Math.min(lines.length, step.endLine);
+                  const chunk = lines.slice(startIdx, endIdx).map((l, i) => `${startIdx + i + 1}: ${l}`).join("\n");
+                  explorationContext += `
+--- READ LINES ${step.startLine}-${step.endLine} FROM ${step.file} ---
+${chunk}
+`;
+                  history.push(`Attempt ${attempts} (Exploration ${explorationAttempts}): Read lines ${step.startLine}-${step.endLine} from ${step.file}`);
+                } catch (err) {
+                  explorationContext += `
+--- FAILED TO READ LINES: ${step.file} ---
+Error: ${err.message}
+`;
+                  history.push(`Attempt ${attempts} (Exploration ${explorationAttempts}): Failed to read lines from ${step.file}`);
+                }
+              } else if (step.action === "list_dir") {
+                console.log(chalk2.cyan(`  - \u{1F4C2} Listing directory: ${step.path}`));
+                try {
+                  const files = readdirSync(resolve7(process.cwd(), step.path));
+                  explorationContext += `
+--- DIRECTORY: ${step.path} ---
+${files.join("\n")}
+`;
+                  history.push(`Attempt ${attempts} (Exploration ${explorationAttempts}): Listed directory ${step.path}`);
+                } catch (err) {
+                  explorationContext += `
+--- FAILED TO LIST DIRECTORY: ${step.path} ---
+Error: ${err.message}
+`;
+                  history.push(`Attempt ${attempts} (Exploration ${explorationAttempts}): Failed to list directory ${step.path}`);
+                }
+              } else if (step.action === "replace_lines") {
+                needsToBreakAndRunTests = true;
+                console.log(chalk2.cyan(`  - \u{1F4DD} Replace lines ${step.startLine}-${step.endLine} in ${step.file.split("/").pop()}`));
+                history.push(`Attempt ${attempts}: Replaced lines ${step.startLine}-${step.endLine} in ${step.file.split("/").pop()}`);
+                recentPatches.push(step.replacementCode);
+                if (recentPatches.length > 3) recentPatches.shift();
+                if (recentPatches.length === 3 && recentPatches.every((code) => code === step.replacementCode)) {
+                  console.log(chalk2.red(`\u2716 AI generated the exact same patch 3 times in a row. Forcibly breaking infinite loop.`));
+                  return "failed";
+                }
+              } else if (step.action === "install_deps") {
+                needsToBreakAndRunTests = true;
+                console.log(chalk2.cyan(`  - \u{1F4E6} Install dependencies: ${step.deps.join(", ")}`));
+                history.push(`Attempt ${attempts}: Installed dependencies ${step.deps.join(", ")}`);
+              } else if (step.action === "abort") {
+                needsToBreakAndRunTests = true;
+                console.log(chalk2.cyan(`  - \u{1F6D1} Abort: ${step.reason}`));
+                history.push(`Attempt ${attempts}: Aborted with reason: ${step.reason}`);
+                if (sourceFilePath) {
+                  const bugFile = resolve7(process.cwd(), "aitest-bugs.md");
+                  const fs = await import("fs");
+                  fs.appendFileSync(bugFile, `
+## Source Code Issue Detected in ${sourceFilePath}
+**AI Reasoning**: ${plan.reasoning || "No reasoning provided."}
+**Abort Reason**: ${step.reason}
+`, "utf-8");
+                  console.log(chalk2.yellow(`  \u26A0 Issue logged to aitest-bugs.md for later fixing.`));
+                }
+              }
+            }
+            if (needsToBreakAndRunTests) {
+              const execResult = await this._executePlan(plan);
+              if (execResult === "abort") {
+                console.log(chalk2.red(`\u2716 AI plan execution aborted.`));
+                return "skipped";
+              }
+              planExecuted = true;
+            } else {
+              await new Promise((r) => setTimeout(r, 500));
+            }
+          }
+          if (!planExecuted) {
+            console.log(chalk2.red(`\u2716 AI exhausted exploration limit without applying a patch. Giving up on this file.`));
+            return "failed";
+          }
+          if (existsSync4(testFilePath)) {
+            testCode = readFileSync6(testFilePath, "utf-8");
+          }
+        }
+        console.log(chalk2.red(`
+\u2716 Exhausted ${maxAttempts} AI attempts without passing.`));
+        return "failed";
+      }
+      /** Derive the .test.* filename from a source file path. */
+      _deriveTestPath(sourceFilePath) {
+        const ext = sourceFilePath.substring(sourceFilePath.lastIndexOf("."));
+        const base = sourceFilePath.substring(
+          sourceFilePath.lastIndexOf("/") + 1,
+          sourceFilePath.length - ext.length
+        );
+        const dir = dirname2(sourceFilePath);
+        return resolve7(dir, `${base}.test${ext}`);
+      }
+      /** Prompt the LLM for a JSON plan based on a failed test run. */
+      async _requestPlan(errorOutput, testCode, testFilePath, history, sourceFilePath, explorationContext = "") {
+        const historyContext = history.length > 0 ? `
+--- PREVIOUS ACTIONS TAKEN ---
+${history.join("\n")}
+WARNING: The test is still failing. Do NOT suggest the exact same action again.` : "";
+        let sourceContext = "";
+        if (sourceFilePath && existsSync4(sourceFilePath)) {
+          const sourceContent = readFileSync6(sourceFilePath, "utf-8");
+          const sourceLines = sourceContent.split("\n");
+          if (sourceLines.length > 1e3) {
+            sourceContext = `
+--- SOURCE FILE INFO ---
+The source file (${sourceFilePath}) is massive (${sourceLines.length} lines) and has been omitted from this prompt to save context and improve accuracy. You MUST use the "search_file" and "read_lines" actions to dynamically read the specific functions you need to fix the test.`;
+          } else {
+            sourceContext = `
+--- SOURCE FILE (${sourceFilePath}) ---
+${sourceContent}`;
+          }
+        }
+        const workspaceContext = this.workspaceMap ? `
+--- WORKSPACE FILE STRUCTURE ---
+${this.workspaceMap}` : "";
+        const explorationContextString = explorationContext ? `
+--- EXPLORATION CONTEXT ---
+${explorationContext}` : "";
+        const isCloud = this._isCloudProvider();
+        const testLines = testCode.split("\n");
+        let testContext = "";
+        if (!isCloud && testLines.length > 500) {
+          testContext = `
+--- TEST FILE INFO ---
+The test file (${testFilePath}) is massive (${testLines.length} lines) and has been omitted to support Local LLMs. Look at the ERROR OUTPUT to find the line number of the failing test (e.g., file.test.js:6540). You MUST use the "read_lines" action to read the test file around that line number before applying a "replace_lines" patch.`;
+        } else {
+          const testCodeWithLines = testLines.map((line, idx) => `${idx + 1}: ${line}`).join("\n");
+          testContext = `
+--- TEST FILE (${testFilePath}) ---
+${testCodeWithLines}`;
+        }
+        const prompt = `You are an expert QA engineer. The following test has failed.${sourceContext}${workspaceContext}${explorationContextString}${testContext}
+--- ERROR OUTPUT ---
+${errorOutput}${historyContext}
+Based on this information, suggest ONE JSON plan describing the next actionable step. The JSON must follow this schema:
+{ "reasoning": "<explain the failure and your fix or exploration strategy>", "steps": [ { "action": "replace_lines", "file": "${testFilePath}", "startLine": <number>, "endLine": <number>, "replacementCode": "<new test code to replace the specified lines>" } | { "action": "search_file", "file": "<path>", "query": "<string to search for>" } | { "action": "read_lines", "file": "<path>", "startLine": <number>, "endLine": <number> } | { "action": "read_file", "path": "<relative path to file>" } | { "action": "list_dir", "path": "<relative path to dir>" } | { "action": "install_deps", "deps": ["<package>"] } | { "action": "abort", "reason": "<text>" } ] }
+CRITICAL RULES:
+1. To explore massive files safely, use "search_file" to find function signatures, then "read_lines" to read the implementation block. For small files, use "read_file". If you need to see what files exist in a directory, use "list_dir".
+2. You may ONLY patch the test file (${testFilePath}) using the "replace_lines" action.
+3. For "replace_lines", provide the exact startLine and endLine numbers based on the line numbers shown in the TEST FILE block. To insert code without removing any lines, set startLine and endLine to the line number where you want to insert.
+4. Do NOT wrap the JSON in markdown code blocks. Output ONLY the raw JSON object.
+5. If you cannot fix the issue, return an "abort" action.`;
+        try {
+          const raw = await askAI(this.config, "Generate a JSON plan to fix the failing test.", prompt);
+          const plan = this._parsePlan(raw);
+          if (plan && this._validatePlan(plan, testFilePath)) return plan;
+          return null;
+        } catch (error) {
+          console.log(chalk2.red(`
+\u2716 AI request failed: ${error.message || error}`));
+          return null;
+        }
+      }
+      /** Extract JSON from LLM response and parse it. */
+      _parsePlan(text) {
+        try {
+          const cleaned = text.replace(/```json/g, "").replace(/```/g, "").trim();
+          const match = cleaned.match(/\{[\s\S]*\}/);
+          if (!match) return null;
+          const obj = JSON.parse(match[0]);
+          if (obj && Array.isArray(obj.steps)) return obj;
+        } catch (e) {
+        }
+        return null;
+      }
+      /** Validate that the plan only contains allowed actions and safe file paths. */
+      _validatePlan(plan, testFilePath) {
+        const allowed = /* @__PURE__ */ new Set(["replace_lines", "install_deps", "abort", "read_file", "list_dir", "search_file", "read_lines"]);
+        for (const step of plan.steps) {
+          if (!allowed.has(step.action)) return false;
+          if (step.action === "replace_lines") {
+            const abs = resolve7(step.file);
+            if (abs !== testFilePath) return false;
+            if (typeof step.startLine !== "number") return false;
+            if (typeof step.endLine !== "number") return false;
+            if (typeof step.replacementCode !== "string") return false;
+          }
+          if (step.action === "install_deps") {
+            if (!Array.isArray(step.deps)) return false;
+          }
+          if (step.action === "read_file" || step.action === "list_dir") {
+            if (typeof step.path !== "string") return false;
+          }
+          if (step.action === "search_file") {
+            if (typeof step.file !== "string") return false;
+            if (typeof step.query !== "string") return false;
+          }
+          if (step.action === "read_lines") {
+            if (typeof step.file !== "string") return false;
+            if (typeof step.startLine !== "number") return false;
+            if (typeof step.endLine !== "number") return false;
+          }
+        }
+        return true;
+      }
+      /** Execute a validated plan step‑by‑step. */
+      async _executePlan(plan) {
+        for (const step of plan.steps) {
+          switch (step.action) {
+            case "replace_lines": {
+              const fileContent = existsSync4(step.file) ? readFileSync6(step.file, "utf-8") : "";
+              const lines = fileContent.split("\n");
+              const startIdx = Math.max(0, step.startLine - 1);
+              const endIdx = Math.min(lines.length, step.endLine);
+              const newLines = step.replacementCode.split("\n");
+              lines.splice(startIdx, endIdx - startIdx, ...newLines);
+              writeFileSync3(step.file, lines.join("\n"), "utf-8");
+              break;
+            }
+            case "install_deps": {
+              const deps = step.deps.join(" ");
+              try {
+                await execAsync5(`npm install --save-dev ${deps}`, { cwd: process.cwd() });
+              } catch (e) {
+                return "abort";
+              }
+              break;
+            }
+            case "abort": {
+              return "abort";
+            }
+          }
+        }
+        return "continue";
+      }
+    };
+  }
+});
+
+// src/core/agentic.js
+var agentic_exports = {};
+__export(agentic_exports, {
+  AgenticPlanner: () => AgenticPlanner
+});
+var init_agentic2 = __esm({
+  "src/core/agentic.js"() {
+    "use strict";
+    init_agentic();
+  }
+});
+
+// src/commands/generate.ts
+import { Command as Command3 } from "commander";
+import { exec as exec6 } from "child_process";
+import { promisify as promisify6 } from "util";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync4, existsSync as existsSync5 } from "fs";
+import { resolve as resolve8, relative, dirname as dirname3, basename, extname } from "path";
+import fg3 from "fast-glob";
+import chalk3 from "chalk";
+async function generateTestForFile(filePath, config2, projectInfo, forceUpdate = false, evaluateExisting = false, workspaceMap = "") {
+  const relPath = relative(process.cwd(), filePath);
+  const dir = dirname3(filePath);
+  const ext = extname(filePath);
+  const name = basename(filePath, ext);
+  const testFilePath = resolve8(dir, `${name}.test${ext}`);
+  const spinner = logger.spinner(`Analyzing ${relPath}...`).start();
+  if (existsSync5(testFilePath) && !forceUpdate) {
+    spinner.info(`Evaluating existing test file for missing coverage: ${relPath}`);
+    evaluateExisting = true;
+  }
+  let fileContent = "";
+  try {
+    fileContent = readFileSync7(filePath, "utf-8");
+  } catch (e) {
+    spinner.fail(`Could not read file ${filePath}`);
+    return "failed";
+  }
+  const depsContext = await scanDependencies(filePath);
+  let additionalContext = depsContext ? `
+
+--- ARCHITECTURAL CONTEXT (DEPENDENCIES) ---
+${depsContext}` : "";
+  if (workspaceMap) {
+    additionalContext += `
+
+--- WORKSPACE FILE STRUCTURE ---
+${workspaceMap}`;
+  }
+  let existingTestContext = "";
+  if (existsSync5(testFilePath)) {
+    const existingCode = readFileSync7(testFilePath, "utf-8");
+    existingTestContext = `
+
+--- EXISTING TEST SUITE (NEEDS IMPROVEMENT) ---
+${existingCode}
+`;
+  }
+  try {
+    const promptContext = `Original file name: ${relPath}
+
+Code:
+${fileContent}
+
+${additionalContext}${existingTestContext}`;
+    let promptInstructions = "";
+    if (existingTestContext) {
+      if (forceUpdate) {
+        promptInstructions = "You are an expert QA and software testing engineer. The provided existing test suite does not have 100% code coverage. Analyze the source code and the existing test suite, and REWRITE the test suite to include new test cases that cover the missing branches and logic. Output ONLY valid executable code (with markdown code blocks) and nothing else.";
+      } else if (evaluateExisting) {
+        promptInstructions = 'You are an expert QA and software testing engineer. Analyze the source code and the existing test suite to evaluate its code coverage. If the existing test suite is missing test cases for certain branches or logic, REWRITE the test suite to include new test cases that cover the missing parts. Output ONLY valid executable code (with markdown code blocks) and nothing else. If the existing test suite already fully covers the source code, reply ONLY with the exact string "SKIP_FILE".';
+      }
+    } else {
+      const testFramework = projectInfo.testRunner === "unknown" ? "Jest" : projectInfo.testRunner;
+      promptInstructions = `You are an expert QA and software testing engineer. Generate a comprehensive unit test suite for the provided code. Output ONLY valid executable code (with markdown code blocks) and nothing else. The target test framework is ${testFramework}. If the file is purely type definitions, interfaces, simple exports, or does not contain testable logic, reply ONLY with the exact string "SKIP_FILE" and do not generate any code. You will be provided with the target code and its imported dependencies to ensure you have the full architectural context.
+CRITICAL: If testing Prisma or databases, use standard mock techniques (e.g. jest-mock-extended or vi.mock). If using Vitest, use vi.mocked() to mock imported functions to avoid TypeScript errors like 'Property does not exist on type'.`;
+    }
+    const generatedCode = await askAI(config2, promptInstructions, promptContext);
+    if (generatedCode.includes("SKIP_FILE")) {
+      spinner.info(`Skipped ${relPath}: No testable logic found.`);
+      return "skipped";
+    }
+    let testCode = generatedCode;
+    const match = generatedCode.match(/```(?:javascript|typescript|ts|js)?\n([\s\S]*?)```/) || generatedCode.match(/```[\w]*\n([\s\S]*?)```/);
+    if (match && match[1]) {
+      testCode = match[1].trim();
+    }
+    if (!testCode || testCode.trim() === "") {
+      spinner.warn(`AI returned empty code for ${relPath}. Skipping to prevent writing an empty file.`);
+      return "skipped";
+    }
+    writeFileSync4(testFilePath, testCode, "utf-8");
+    spinner.stop();
+    return "generated";
+  } catch (error) {
+    spinner.fail(`Error generating test for ${relPath}: ${error.message}`);
+    return "failed";
+  }
+}
+var execAsync6, generateCommand;
+var init_generate = __esm({
+  "src/commands/generate.ts"() {
+    "use strict";
+    init_config();
+    init_logger();
+    init_detector();
+    init_ai();
+    init_scanner();
+    execAsync6 = promisify6(exec6);
+    generateCommand = new Command3("generate").description("Generate missing unit tests for the current project using Agentic AI").option("-a, --all", "Generate tests for all missing files").option("-f, --file <path>", "Generate tests for a specific file").option("-u, --force-update", "Force rewrite existing test files (ignores code coverage logic)").option("-e, --evaluate-existing", "Evaluate existing tests and ONLY rewrite if missing code coverage").action(async (options) => {
+      const config2 = await loadConfig();
+      if (!config2) {
+        logger.error("Configuration not found. Run `aitest init` first.");
+        return;
+      }
+      if (!options.file && !options.all && !options.coverage) {
+        logger.error("Please specify --file <path>, --all, or --coverage");
+        return;
+      }
+      const projectInfo = detectProjectInfo();
+      const workspaceMap = await generateWorkspaceMap();
+      if (options.coverage) {
+        logger.info("Running coverage-driven test generation...");
+        let testCommand = "npm test -- --coverage";
+        if (projectInfo.testRunner === "mocha" || projectInfo.testRunner === "unknown") {
+          testCommand = "npm test --coverage";
+        }
+        const spinner = logger.spinner("Running test suite to collect coverage metrics...").start();
+        try {
+          const { stdout } = await execAsync6(testCommand, { cwd: process.cwd() });
+          spinner.succeed("Coverage data collected.");
+          const analyzeSpinner = logger.spinner("Analyzing coverage gaps with AI...").start();
+          const aiResponse = await askAI(
+            config2,
+            'Extract all file paths from this coverage report that have less than 100% coverage (statement, branch, or function). Return ONLY a JSON array of string paths (e.g. ["src/math.js"]). Do not output anything else. If no files are listed, return [].',
+            `STDOUT:
+${stdout.slice(-5e3)}`
+          );
+          analyzeSpinner.succeed("Coverage gaps identified.");
+          const match = aiResponse.match(/\[[\s\S]*\]/);
+          if (match) {
+            const filesToFix = JSON.parse(match[0]);
+            if (filesToFix.length === 0) {
+              logger.success("All files have 100% coverage!");
+              return;
+            }
+            logger.info(`Found ${filesToFix.length} files missing coverage. Starting targeted generation...`);
+            for (const file of filesToFix) {
+              const fullPath = resolve8(process.cwd(), file);
+              if (existsSync5(fullPath)) {
+                await generateTestForFile(fullPath, config2, projectInfo, true, false, workspaceMap);
+              }
+            }
+            logger.success(`
+Finished coverage-driven generation for ${filesToFix.length} files.`);
+            return;
+          } else {
+            logger.error("Failed to parse AI response for coverage files.");
+            return;
+          }
+        } catch (e) {
+          spinner.fail(`Failed to collect coverage data: ${e.message}`);
+          return;
+        }
+      }
+      if (options.all) {
+        logger.info("Scanning project for source files...");
+        const files = await fg3(["**/*.{js,ts,jsx,tsx}"], {
+          ignore: [
+            "**/node_modules/**",
+            "**/dist/**",
+            "**/build/**",
+            "**/coverage/**",
+            "**/*.test.*",
+            "**/*.spec.*",
+            "**/vite.config.*",
+            "**/tsup.config.*",
+            "**/.*"
+          ],
+          cwd: process.cwd()
+        });
+        if (files.length === 0) {
+          logger.info("No source files found.");
+          return;
+        }
+        logger.info(`Found ${files.length} files. Starting test generation using Agentic AI...`);
+        let successCount = 0;
+        let skippedCount = 0;
+        const { AgenticPlanner: AgenticPlanner2 } = await Promise.resolve().then(() => (init_agentic2(), agentic_exports));
+        const planner = new AgenticPlanner2(config2, projectInfo, workspaceMap);
+        const startTime = Date.now();
+        for (let i = 0; i < files.length; i++) {
+          const file = files[i];
+          const fullPath = resolve8(process.cwd(), file);
+          const result = await planner.generateFile(fullPath, { forceUpdate: options.forceUpdate, evaluateExisting: options.evaluateExisting, workspaceMap });
+          if (result === "generated") successCount++;
+          else if (result === "skipped") skippedCount++;
+        }
+        logger.success(`
+Finished! Generated tests for ${successCount} files (Skipped ${skippedCount} files). Total processed: ${files.length}.`);
+        if (successCount > 0) {
+          const elapsedSeconds = Math.floor((Date.now() - startTime) / 1e3);
+          console.log(chalk3.magentaBright(`
+\u2728 AI successfully generated tests for ${successCount} files in ${elapsedSeconds}s! Saved you ~${successCount * 2} hours of typing.`));
+          const terminalLink = (await import("terminal-link")).default;
+          const tweetUrl = `https://twitter.com/intent/tweet?text=I%20just%20used%20%40aitestcli%20to%20autonomously%20generate%20${successCount}%20test%20suites%20in%20${elapsedSeconds}s!%20%F0%9F%A4%AF%0A%0A%23ai%20%23testing%20%23javascript&url=https://www.npmjs.com/package/ai-test-cli`;
+          console.log(chalk3.cyan("\u{1F680} " + terminalLink("Share your win on Twitter!", tweetUrl)));
+          console.log(chalk3.yellow("\u2615 " + terminalLink("Buy the creator a coffee!", "https://buymeacoffee.com/cijaytechnh")) + "\n");
+        }
+        process.exit(0);
+      } else if (options.file) {
+        if (options.file.includes(".test.") || options.file.includes(".spec.")) {
+          logger.error(`
+\u2716 Oops! You passed a test file (${options.file}) to the generate command.`);
+          logger.info(`\u{1F4A1} The 'generate' command expects the SOURCE file (e.g. app/controllers/AdminController.js).`);
+          logger.info(`\u{1F4A1} If you want to evaluate/extend this existing test, point the generate command to the SOURCE file.`);
+          logger.info(`\u{1F4A1} If you want to fix this broken test file, run: aitest fix`);
+          process.exit(1);
+        }
+        const filePath = resolve8(process.cwd(), options.file);
+        const { AgenticPlanner: AgenticPlanner2 } = await Promise.resolve().then(() => (init_agentic2(), agentic_exports));
+        const planner = new AgenticPlanner2(config2, projectInfo, workspaceMap);
+        logger.info(`Starting Agentic test generation for ${options.file}...`);
+        const startTime = Date.now();
+        const result = await planner.generateFile(filePath, { forceUpdate: options.forceUpdate, evaluateExisting: options.evaluateExisting, workspaceMap });
+        if (result === "generated") {
+          const elapsedSeconds = Math.floor((Date.now() - startTime) / 1e3);
+          logger.success(`
+Finished! Successfully generated test for ${options.file}.`);
+          console.log(chalk3.magentaBright(`
+\u2728 AI successfully generated the test suite in ${elapsedSeconds}s! Saved you ~2 hours of typing.`));
+          const terminalLink = (await import("terminal-link")).default;
+          const tweetUrl = `https://twitter.com/intent/tweet?text=I%20just%20used%20%40aitestcli%20to%20autonomously%20generate%20a%20test%20suite%20in%20${elapsedSeconds}s!%20%F0%9F%A4%AF%0A%0A%23ai%20%23testing%20%23javascript&url=https://www.npmjs.com/package/ai-test-cli`;
+          console.log(chalk3.cyan("\u{1F680} " + terminalLink("Share your win on Twitter!", tweetUrl)));
+          console.log(chalk3.yellow("\u2615 " + terminalLink("Buy the creator a coffee!", "https://buymeacoffee.com/cijaytechnh")) + "\n");
+        } else if (result === "skipped") {
+          logger.info(`
+Skipped test generation for ${options.file}.`);
+        } else {
+          logger.error(`
+Failed to generate test for ${options.file}.`);
+        }
+        process.exit(0);
+      }
+    });
+  }
+});
+
+// src/index.ts
+import { Command as Command9 } from "commander";
+import { readFileSync as readFileSync9 } from "fs";
+import { resolve as resolve10 } from "path";
+import { fileURLToPath } from "url";
+
+// src/commands/init.ts
+init_config();
+init_detector();
+init_logger();
+import { Command } from "commander";
+import prompts from "prompts";
+import { existsSync as existsSync2, appendFileSync, readFileSync as readFileSync4 } from "fs";
+import { resolve as resolve5 } from "path";
+
+// src/core/setup.ts
+init_logger();
+import { exec } from "child_process";
+import { promisify } from "util";
+import { resolve as resolve3 } from "path";
+import { readFileSync as readFileSync2, writeFileSync } from "fs";
+var execAsync = promisify(exec);
+async function installTestRunner(projectInfo, targetDir = process.cwd()) {
+  const spinner = logger.spinner("Setting up test runner...").start();
+  const isTs = projectInfo.language === "typescript";
+  const runner = isTs ? "vitest" : "jest";
+  const packages = isTs ? "vitest" : "jest";
+  let installCmd = "";
+  switch (projectInfo.packageManager) {
+    case "npm":
+      installCmd = `npm install -D ${packages}`;
+      break;
+    case "yarn":
+      installCmd = `yarn add -D ${packages}`;
+      break;
+    case "pnpm":
+      installCmd = `pnpm add -D ${packages}`;
+      break;
+    case "bun":
+      installCmd = `bun add -D ${packages}`;
+      break;
+  }
+  try {
+    spinner.text = `Installing ${runner} using ${projectInfo.packageManager}...`;
+    await execAsync(installCmd, { cwd: targetDir });
+    spinner.text = "Updating package.json...";
+    const packageJsonPath = resolve3(targetDir, "package.json");
+    let pkg = {};
+    try {
+      pkg = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
+    } catch (e) {
+      pkg = {};
+    }
+    if (!pkg.scripts) pkg.scripts = {};
+    if (runner === "vitest") {
+      pkg.scripts.test = "vitest run";
+    } else {
+      pkg.scripts.test = "jest";
+    }
+    writeFileSync(packageJsonPath, JSON.stringify(pkg, null, 2), "utf-8");
+    spinner.succeed(`Successfully installed and configured ${runner}!`);
+  } catch (error) {
+    spinner.fail(`Failed to set up test runner: ${error.message}`);
+  }
+}
+
+// src/commands/init.ts
+init_ai();
+
+// src/core/config-fixer.ts
+init_logger();
+import { writeFileSync as writeFileSync2, readFileSync as readFileSync3 } from "fs";
+import { resolve as resolve4 } from "path";
+import { exec as exec2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execAsync2 = promisify2(exec2);
+async function applyConfigFix(configFix, projectInfo, spinner = logger.spinner("Applying fix...")) {
+  spinner.info(`Autonomous Config Fix initiated: ${configFix.reason}`);
+  if (configFix.dependencies && configFix.dependencies.length > 0) {
+    spinner.text = `Installing missing dependencies: ${configFix.dependencies.join(", ")}...`;
+    const installCmd = projectInfo.packageManager === "yarn" ? "yarn add -D" : projectInfo.packageManager === "pnpm" ? "pnpm add -D" : projectInfo.packageManager === "bun" ? "bun add -d" : "npm install -D --legacy-peer-deps";
+    await execAsync2(`${installCmd} ${configFix.dependencies.join(" ")}`, { cwd: process.cwd() });
+  }
+  if (configFix.files && configFix.files.length > 0) {
+    for (const file of configFix.files) {
+      const filePath = resolve4(process.cwd(), file.path);
+      spinner.text = `Writing config file: ${file.path}...`;
+      if (file.path.endsWith("package.json")) {
+        try {
+          const existingPkg = JSON.parse(readFileSync3(filePath, "utf-8"));
+          const newPkg = JSON.parse(file.content);
+          if (newPkg.scripts) {
+            existingPkg.scripts = { ...existingPkg.scripts || {}, ...newPkg.scripts };
+          }
+          if (newPkg.jest) {
+            existingPkg.jest = { ...existingPkg.jest || {}, ...newPkg.jest };
+          }
+          writeFileSync2(filePath, JSON.stringify(existingPkg, null, 2), "utf-8");
+        } catch (e) {
+          spinner.warn(`Failed to safely merge package.json: ${e.message}`);
+        }
+      } else {
+        writeFileSync2(filePath, file.content, "utf-8");
+      }
+    }
+  }
+}
+
+// src/commands/init.ts
+import fg from "fast-glob";
+var initCommand = new Command("init").description("Initialize the project").action(async () => {
+  logger.info("Initializing AI Test CLI...");
+  const projectInfo = detectProjectInfo();
+  logger.info(`Detected Language: ${projectInfo.language}`);
+  logger.info(`Detected Framework: ${projectInfo.framework}`);
+  logger.info(`Detected Test Runner: ${projectInfo.testRunner}`);
+  logger.info(`Detected Package Manager: ${projectInfo.packageManager}`);
+  if (projectInfo.testRunner === "unknown") {
+    const setupRes = await prompts({
+      type: "confirm",
+      name: "installRunner",
+      message: "No test runner detected. Would you like AI Test CLI to automatically install and configure one?",
+      initial: true
+    });
+    if (setupRes.installRunner) {
+      await installTestRunner(projectInfo);
+    }
+  }
+  const response = await prompts([
+    {
+      type: "select",
+      name: "provider",
+      message: "Select AI Provider",
+      choices: [
+        { title: "OpenAI", value: "openai" },
+        { title: "Anthropic", value: "anthropic" },
+        { title: "DeepSeek", value: "deepseek" },
+        { title: "Gemini", value: "gemini" },
+        { title: "Ollama (Local)", value: "ollama" },
+        { title: "Custom (OpenAI Compatible)", value: "custom" }
+      ],
+      initial: 0
+    },
+    {
+      type: "text",
+      name: "model",
+      message: "Enter model name",
+      initial: (prev) => {
+        if (prev === "openai") return "gpt-4o";
+        if (prev === "anthropic") return "claude-3-5-sonnet-latest";
+        if (prev === "deepseek") return "deepseek-coder";
+        if (prev === "gemini") return "gemini-2.5-flash";
+        if (prev === "ollama") return "llama3.1";
+        if (prev === "custom") return "local-model";
+        return "";
+      }
+    },
+    {
+      type: (prev, values) => values.provider === "custom" ? "text" : null,
+      name: "baseURL",
+      message: "Enter API Base URL (e.g., http://localhost:1234/v1)"
+    },
+    {
+      type: (prev, values) => values.provider === "custom" ? "text" : null,
+      name: "customHeaders",
+      message: 'Enter custom headers as "Key: Value, Key2: Value2" (or leave empty)'
+    },
+    {
+      type: (prev, values) => values.provider === "ollama" ? null : "password",
+      name: "apiKey",
+      message: "Enter API Key"
+    }
+  ]);
+  if (!response.provider || !response.model) {
+    logger.error("Initialization aborted.");
+    return;
+  }
+  if (response.apiKey) {
+    const envKeyMap = {
+      openai: "OPENAI_API_KEY",
+      anthropic: "ANTHROPIC_API_KEY",
+      deepseek: "DEEPSEEK_API_KEY",
+      gemini: "GEMINI_API_KEY",
+      custom: "CUSTOM_API_KEY"
+    };
+    const envKey = envKeyMap[response.provider] || "CUSTOM_API_KEY";
+    const envPath = resolve5(process.cwd(), ".env");
+    appendFileSync(envPath, `
+${envKey}=${response.apiKey}
+`, "utf-8");
+    process.env[envKey] = response.apiKey;
+    logger.success(`Saved API key to .env securely.`);
+    const gitignorePath = resolve5(process.cwd(), ".gitignore");
+    let gitignoreContent = "";
+    if (existsSync2(gitignorePath)) {
+      gitignoreContent = readFileSync4(gitignorePath, "utf-8");
+    }
+    if (!gitignoreContent.includes(".env")) {
+      appendFileSync(gitignorePath, "\n.env\n", "utf-8");
+      logger.info("Added .env to .gitignore");
+    }
+  }
+  let parsedHeaders = void 0;
+  if (response.customHeaders && response.customHeaders.trim() !== "") {
+    parsedHeaders = {};
+    const parts = response.customHeaders.split(",");
+    for (const part of parts) {
+      const [key, ...valParts] = part.split(":");
+      if (key && valParts.length > 0) {
+        const cleanKey = key.trim().replace(/^["']|["']$/g, "");
+        const cleanVal = valParts.join(":").trim().replace(/^["']|["']$/g, "");
+        parsedHeaders[cleanKey] = cleanVal;
+      }
+    }
+  }
+  const config2 = {
+    provider: response.provider,
+    model: response.model,
+    baseURL: response.baseURL,
+    customHeaders: parsedHeaders,
+    temperature: 0.1,
+    autoFix: true,
+    maxRetries: -1
+    // Infinite by default
+  };
+  await saveConfig(config2);
+  logger.success("Basic initialization complete.");
+  const setupVerify = await prompts({
+    type: "confirm",
+    name: "verify",
+    message: "Would you like the AI to verify and configure your testing environment right now? (Recommended)",
+    initial: true
+  });
+  if (setupVerify.verify) {
+    const spinner = logger.spinner("Analyzing project setup...").start();
+    try {
+      const pkgPath = resolve5(process.cwd(), "package.json");
+      let pkgContent = "{}";
+      if (existsSync2(pkgPath)) {
+        pkgContent = readFileSync4(pkgPath, "utf-8");
+      }
+      const existingConfigs = await fg(["jest.config.*", "vite.config.*", ".babelrc*", "tsconfig.*", "vitest.config.*"], { cwd: process.cwd(), deep: 1 });
+      const setupContext = `Language: ${projectInfo.language}
+Framework: ${projectInfo.framework}
+Test Runner: ${projectInfo.testRunner}
+Existing Config Files: ${existingConfigs.join(", ") || "None"}
+Package.json:
+${pkgContent}`;
+      const responseCode = await askAI(
+        config2,
+        'You are a testing architecture expert. Analyze this project setup. If the test environment is perfect and ready to run tests, reply exactly with "READY". If it is missing dependencies (e.g., Jest, Vitest, Testing Library, jsdom) or needs config files (e.g., .babelrc, jest.config.js) to support the detected framework, reply ONLY with a JSON block wrapped in ```json starting with {"type": "CONFIG_FIX", "dependencies": ["pkg"], "files": [{"path": ".babelrc", "content": "..."}], "reason": "..."}. CRITICAL: You must escape all newlines within the JSON "content" strings as \\n. DO NOT create duplicate configuration files for the same tool (e.g., if jest.config.js exists, do not create jest.config.ts). If an existing file needs updating, provide the file path of the existing file. Do not output raw unescaped newlines inside the JSON string. Do not output anything else.',
+        setupContext
+      );
+      const configFixMatch = responseCode.match(/```json\s*(\{[\s\S]*?"type":\s*"CONFIG_FIX"[\s\S]*?\})\s*```/);
+      if (configFixMatch && configFixMatch[1]) {
+        const configFix = JSON.parse(configFixMatch[1]);
+        await applyConfigFix(configFix, projectInfo, spinner);
+        spinner.succeed("Test environment successfully scaffolded!");
+      } else {
+        spinner.succeed("Test environment looks perfectly configured!");
+      }
+    } catch (e) {
+      spinner.fail(`Setup verification failed: ${e.message}`);
+    }
+  }
+  logger.success("You can now use `aitest run` or `aitest generate`.");
+});
+
+// src/commands/run.ts
+init_config();
+init_logger();
+init_ai();
+init_detector();
+import { Command as Command2 } from "commander";
+import { exec as exec3 } from "child_process";
+import { promisify as promisify3 } from "util";
+var execAsync3 = promisify3(exec3);
+var runCommand = new Command2("run").description("Run tests and analyze with AI (implicitly tracks coverage)").action(async () => {
+  const config2 = await loadConfig();
+  if (!config2) {
+    logger.error("Configuration not found. Run `aitest init` first.");
+    return;
+  }
+  const projectInfo = detectProjectInfo();
+  let testCommand = "npm test -- --coverage";
+  if (projectInfo.testRunner === "mocha" || projectInfo.testRunner === "unknown") {
+    testCommand = "npm test --coverage";
+  }
+  const spinner = logger.spinner(`Running tests with coverage (${testCommand})...`).start();
+  let stdoutStr = "";
+  let stderrStr = "";
+  let testFailed = false;
+  try {
+    const { stdout, stderr } = await execAsync3(testCommand);
+    stdoutStr = stdout;
+    stderrStr = stderr;
+    spinner.succeed("Tests passed!");
+  } catch (error) {
+    testFailed = true;
+    stdoutStr = error.stdout || "";
+    stderrStr = error.stderr || error.message;
+    spinner.fail("Tests failed.");
+  }
+  const outputToAnalyze = `
+STDOUT:
+${stdoutStr.slice(-2e3)}
+
+STDERR:
+${stderrStr.slice(-2e3)}
+    `.trim();
+  logger.info("Analyzing test results with AI...");
+  const analyzeSpinner = logger.spinner("Thinking...").start();
+  try {
+    const analysis = await askAI(
+      config2,
+      "You are an expert QA and software testing engineer. Analyze the provided test output and code coverage metrics. Keep it concise. If there are failures, provide a clear summary of what failed and why. Also, briefly analyze the coverage table and suggest what areas of the code need more tests.",
+      outputToAnalyze
+    );
+    analyzeSpinner.succeed("Analysis complete");
+    console.log("\n" + analysis + "\n");
+  } catch (error) {
+    analyzeSpinner.fail("AI analysis failed.");
+    logger.error(error.message);
+  }
+});
+
+// src/index.ts
+init_generate();
+
+// src/commands/explain.ts
+init_config();
+init_logger();
+init_ai();
+import { Command as Command4 } from "commander";
+import { exec as exec7 } from "child_process";
+import { promisify as promisify7 } from "util";
+var execAsync7 = promisify7(exec7);
+var explainCommand = new Command4("explain").description("Explains test failures in plain English").action(async () => {
+  const config2 = await loadConfig();
+  if (!config2) {
+    logger.error("Configuration not found. Run `aitest init` first.");
+    return;
+  }
+  const spinner = logger.spinner("Running tests to gather failure data...").start();
+  let stdoutStr = "";
+  let stderrStr = "";
+  try {
+    await execAsync7("npm test");
+    spinner.succeed("Tests passed! Nothing to explain.");
+    return;
+  } catch (error) {
+    stdoutStr = error.stdout || "";
+    stderrStr = error.stderr || error.message;
+    spinner.info("Test failure detected.");
+  }
+  const outputToAnalyze = `
+STDOUT:
+${stdoutStr.slice(-2e3)}
+
+STDERR:
+${stderrStr.slice(-2e3)}
+    `.trim();
+  logger.info("Analyzing root cause with AI...");
+  const analyzeSpinner = logger.spinner("Thinking...").start();
+  try {
+    const explanation = await askAI(
+      config2,
+      "You are an expert QA and software testing engineer. The user has failing tests. Explain the failure in plain English. Include:\n- Root cause\n- Stack analysis\n- Suggested fixes",
+      outputToAnalyze
+    );
+    analyzeSpinner.succeed("Explanation ready:");
+    console.log("\n" + explanation + "\n");
+  } catch (error) {
+    analyzeSpinner.fail("AI explanation failed.");
+    logger.error(error.message);
+  }
+});
+
+// src/commands/doctor.ts
+init_config();
+init_logger();
+init_detector();
+init_ai();
+import { Command as Command5 } from "commander";
+var doctorCommand = new Command5("doctor").description("Verify installation, configuration, and environment").action(async () => {
+  logger.info("Running AI Test CLI Diagnostics...\n");
+  let allChecksPassed = true;
+  const configSpinner = logger.spinner("Checking configuration...").start();
+  const config2 = await loadConfig();
+  if (config2) {
+    configSpinner.succeed("Configuration found");
+  } else {
+    configSpinner.fail("Configuration missing. Run `aitest init`");
+    allChecksPassed = false;
+  }
+  const apiSpinner = logger.spinner("Checking API key...").start();
+  if (config2?.apiKey || process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY || process.env.GEMINI_API_KEY) {
+    apiSpinner.succeed("API key configured");
+  } else {
+    apiSpinner.warn("No explicit API key found in config or environment variables (might be okay for local models)");
+  }
+  if (config2) {
+    const modelSpinner = logger.spinner(`Testing access to ${config2.provider} (${config2.model})...`).start();
+    try {
+      const response = await askAI(config2, 'Reply with exactly "OK"', "Test connection");
+      if (response.includes("OK") || response.trim() !== "") {
+        modelSpinner.succeed("Model connection successful");
+      } else {
+        modelSpinner.warn("Model responded, but unexpectedly");
+      }
+    } catch (error) {
+      modelSpinner.fail(`Model connection failed: ${error.message}`);
+      allChecksPassed = false;
+    }
+  }
+  const envSpinner = logger.spinner("Checking project environment...").start();
+  const projectInfo = detectProjectInfo();
+  if (projectInfo.packageManager !== "npm" && projectInfo.packageManager !== "yarn" && projectInfo.packageManager !== "pnpm" && projectInfo.packageManager !== "bun") {
+    envSpinner.fail("Supported package manager not found");
+    allChecksPassed = false;
+  } else if (projectInfo.testRunner === "unknown") {
+    envSpinner.warn(`Test runner not explicitly detected. Fallback may be used.`);
+  } else {
+    envSpinner.succeed(`Project environment valid (${projectInfo.language}, ${projectInfo.packageManager}, ${projectInfo.testRunner})`);
+  }
+  console.log("\n--- Diagnostic Summary ---");
+  if (allChecksPassed) {
+    logger.success("\u2705 All critical checks passed. You are ready to generate tests!");
+  } else {
+    logger.warn("\u26A0\uFE0F Some checks failed. Please resolve the issues above before proceeding.");
+  }
+});
+
+// src/commands/scan.ts
+init_logger();
+init_detector();
+import { Command as Command6 } from "commander";
+import fg4 from "fast-glob";
+var scanCommand = new Command6("scan").description("Analyze the repository for testing health").action(async () => {
+  logger.info("Scanning repository...\n");
+  const spinner = logger.spinner("Analyzing files and configuration...").start();
+  const projectInfo = detectProjectInfo();
+  try {
+    const sourceFiles = await fg4(["**/*.{js,ts,jsx,tsx}"], {
+      ignore: [
+        "**/node_modules/**",
+        "**/dist/**",
+        "**/build/**",
+        "**/coverage/**",
+        "**/*.test.*",
+        "**/*.spec.*",
+        "**/vite.config.*",
+        "**/tsup.config.*",
+        "**/.*"
+      ],
+      cwd: process.cwd()
+    });
+    const testFiles = await fg4(["**/*.test.{js,ts,jsx,tsx}", "**/*.spec.{js,ts,jsx,tsx}"], {
+      ignore: ["**/node_modules/**", "**/dist/**", "**/build/**", "**/coverage/**"],
+      cwd: process.cwd()
+    });
+    const sourceBases = sourceFiles.map((f) => {
+      const parts = f.split("/");
+      const name = parts[parts.length - 1];
+      return name.replace(/\.(js|ts|jsx|tsx)$/, "");
+    });
+    const testBases = testFiles.map((f) => {
+      const parts = f.split("/");
+      const name = parts[parts.length - 1];
+      return name.replace(/\.(test|spec)\.(js|ts|jsx|tsx)$/, "");
+    });
+    let coveredFiles = 0;
+    const missingTestsFiles = [];
+    for (let i = 0; i < sourceFiles.length; i++) {
+      const base = sourceBases[i];
+      if (testBases.includes(base)) {
+        coveredFiles++;
+      } else {
+        missingTestsFiles.push(sourceFiles[i]);
+      }
+    }
+    const coverageEstimate = sourceFiles.length > 0 ? Math.round(coveredFiles / sourceFiles.length * 100) : 100;
+    let riskScore = "Low";
+    let riskColor = "\x1B[32m";
+    if (coverageEstimate < 40) {
+      riskScore = "High";
+      riskColor = "\x1B[31m";
+    } else if (coverageEstimate < 70) {
+      riskScore = "Medium";
+      riskColor = "\x1B[33m";
+    }
+    const resetColor = "\x1B[0m";
+    spinner.succeed("Analysis complete\n");
+    console.log("\u{1F4CA} Repository Scan Report\n");
+    console.log("--- Architecture ---");
+    console.log(`Language:        ${projectInfo.language}`);
+    console.log(`Framework:       ${projectInfo.framework}`);
+    console.log(`Test Runner:     ${projectInfo.testRunner}`);
+    console.log(`Package Manager: ${projectInfo.packageManager}
+`);
+    console.log("--- Metrics ---");
+    console.log(`Total Source Files: ${sourceFiles.length}`);
+    console.log(`Total Test Files:   ${testFiles.length}`);
+    console.log(`Coverage Estimate:  ${coverageEstimate}% (based on file pairing)`);
+    console.log(`Risk Score:         ${riskColor}${riskScore}${resetColor}
+`);
+    console.log("--- Missing Tests (Top 10) ---");
+    if (missingTestsFiles.length === 0) {
+      console.log("All source files appear to have matching test files! \u{1F389}");
+    } else {
+      const displayLimit = Math.min(10, missingTestsFiles.length);
+      for (let i = 0; i < displayLimit; i++) {
+        console.log(`- ${missingTestsFiles[i]}`);
+      }
+      if (missingTestsFiles.length > 10) {
+        console.log(`... and ${missingTestsFiles.length - 10} more.`);
+      }
+      console.log("\nRun `aitest generate --all` to automatically generate missing tests.");
+    }
+  } catch (error) {
+    spinner.fail(`Scan failed: ${error.message}`);
+  }
+});
+
+// src/commands/config.ts
+init_config();
+init_logger();
+import { Command as Command7 } from "commander";
+var configCommand = new Command7("config").description("Manage settings (e.g., provider, model, apiKey)");
+configCommand.command("set <key> <value>").description("Set a configuration value").action(async (key, value) => {
+  let config2 = await loadConfig();
+  if (!config2) {
+    config2 = { provider: "openai", model: "gpt-4o" };
+  }
+  let parsedValue = value;
+  if (value === "true") parsedValue = true;
+  if (value === "false") parsedValue = false;
+  if (!isNaN(Number(value))) parsedValue = Number(value);
+  config2[key] = parsedValue;
+  await saveConfig(config2);
+});
+configCommand.command("list").description("List current configuration").action(async () => {
+  const config2 = await loadConfig();
+  if (!config2) {
+    logger.warn("No configuration found. Run `aitest init`.");
+    return;
+  }
+  console.log("\n--- Current Configuration ---");
+  for (const [key, value] of Object.entries(config2)) {
+    if (key === "apiKey") {
+      console.log(`${key}: ********* (Hidden)`);
+    } else {
+      console.log(`${key}: ${value}`);
+    }
+  }
+  console.log("---------------------------\n");
+});
+
+// src/commands/fix.ts
+init_config();
+init_logger();
+init_detector();
+init_ai();
+import { Command as Command8 } from "commander";
+import { exec as exec8 } from "child_process";
+import { promisify as promisify8 } from "util";
+import { existsSync as existsSync6 } from "fs";
+import { resolve as resolve9, dirname as dirname4, basename as basename2, extname as extname2 } from "path";
+import chalk4 from "chalk";
+var execAsync8 = promisify8(exec8);
+var fixCommand = new Command8("fix").description("Attempts automatic repair of failing tests using Agentic AI").action(async (options) => {
+  const config2 = await loadConfig();
+  if (!config2) {
+    logger.error("Configuration not found. Run `aitest init` first.");
+    return;
+  }
+  logger.info("Starting test suite to identify failures using Agentic AI...\n");
+  const projectInfo = detectProjectInfo();
+  let testCommand = "npm test";
+  if (projectInfo.testRunner === "vitest") {
+    testCommand = "npx vitest run";
+  } else if (projectInfo.testRunner === "jest") {
+    testCommand = "npx jest";
+  } else if (projectInfo.testRunner === "mocha") {
+    testCommand = "npx mocha";
+  }
+  const spinner = logger.spinner(`Running tests (${testCommand})...`).start();
+  let stdoutStr = "";
+  let stderrStr = "";
+  let testFailed = false;
+  try {
+    const { stdout, stderr } = await execAsync8(testCommand);
+    stdoutStr = stdout;
+    stderrStr = stderr;
+    spinner.succeed("Tests passed! No fixing needed.");
+    return;
+  } catch (error) {
+    testFailed = true;
+    stdoutStr = error.stdout || "";
+    stderrStr = error.stderr || error.message;
+    spinner.warn("Tests failed. Starting AI repair flow...");
+  }
+  const analyzeSpinner = logger.spinner("Analyzing test failure to identify the failing file...").start();
+  const outputToAnalyze = `
+STDOUT:
+${stdoutStr.slice(-3e3)}
+
+STDERR:
+${stderrStr.slice(-3e3)}
+    `.trim();
+  try {
+    const aiResponse = await askAI(
+      config2,
+      'You are an expert QA engineer. Analyze the following test failure output. Identify the primary test file that is failing. Return ONLY the exact file path (relative to project root) of the failing test file. Do not add any extra text. If you cannot find a failing file, return "UNKNOWN".',
+      outputToAnalyze
+    );
+    const failingFile = aiResponse.trim();
+    if (failingFile === "UNKNOWN" || failingFile === "") {
+      analyzeSpinner.fail("Could not identify a failing test file from the output.");
+      return;
+    }
+    const fullPath = resolve9(process.cwd(), failingFile);
+    if (!existsSync6(fullPath)) {
+      analyzeSpinner.fail(`AI identified ${failingFile} as the failing file, but it does not exist.`);
+      return;
+    }
+    analyzeSpinner.succeed(`Identified failing test file: ${failingFile}`);
+    const dir = dirname4(fullPath);
+    const ext = extname2(fullPath);
+    const name = basename2(fullPath, ext).replace(/\.test|\.spec/, "");
+    const possibleSourceFiles = [
+      resolve9(dir, `${name}.ts`),
+      resolve9(dir, `${name}.js`),
+      resolve9(dir, `${name}.tsx`),
+      resolve9(dir, `${name}.jsx`),
+      resolve9(dir, `../${name}.ts`),
+      // one level up might work
+      resolve9(dir, `../${name}.js`)
+    ];
+    let sourceAbsPath = void 0;
+    for (const sf of possibleSourceFiles) {
+      if (existsSync6(sf)) {
+        sourceAbsPath = sf;
+        break;
+      }
+    }
+    const { AgenticPlanner: AgenticPlanner2 } = await Promise.resolve().then(() => (init_agentic2(), agentic_exports));
+    const { generateWorkspaceMap: generateWorkspaceMap2 } = await Promise.resolve().then(() => (init_scanner(), scanner_exports));
+    const startTime = Date.now();
+    const workspaceMap = await generateWorkspaceMap2();
+    const planner = new AgenticPlanner2(config2, projectInfo, workspaceMap);
+    logger.info(`Delegating repair of ${failingFile} to AgenticPlanner...`);
+    const plannerResult = await planner.fixTestFile(fullPath, sourceAbsPath);
+    if (plannerResult === "generated") {
+      const elapsedSeconds = Math.floor((Date.now() - startTime) / 1e3);
+      logger.success(`\u2705 Auto-repair flow finished successfully for ${failingFile}.`);
+      console.log(chalk4.magentaBright(`
+\u2728 AI successfully fixed the broken tests in ${elapsedSeconds}s! Saved you ~1 hour of debugging.`));
+      const terminalLink = (await import("terminal-link")).default;
+      const tweetUrl = `https://twitter.com/intent/tweet?text=I%20just%20used%20%40aitestcli%20to%20autonomously%20fix%20my%20broken%20test%20suite%20in%20${elapsedSeconds}s!%20%F0%9F%A4%AF%0A%0A%23ai%20%23testing%20%23javascript&url=https://www.npmjs.com/package/ai-test-cli`;
+      console.log(chalk4.cyan("\u{1F680} " + terminalLink("Share your win on Twitter!", tweetUrl)));
+      console.log(chalk4.yellow("\u2615 " + terminalLink("Buy the creator a coffee!", "https://buymeacoffee.com/cijaytechnh")) + "\n");
+    } else {
+      logger.error(`\u2716 Auto-repair flow failed or aborted for ${failingFile}.`);
+    }
+    process.exit(0);
+  } catch (error) {
+    analyzeSpinner.fail(`Repair flow failed: ${error.message}`);
+    process.exit(1);
+  }
+});
+
+// src/index.ts
+var __dirname = fileURLToPath(new URL(".", import.meta.url));
+var packageJson = JSON.parse(readFileSync9(resolve10(__dirname, "../package.json"), "utf-8"));
+var program = new Command9();
+program.name("aitest").description(packageJson.description).version(packageJson.version);
+program.addCommand(initCommand);
+program.addCommand(runCommand);
+program.addCommand(generateCommand);
+program.addCommand(explainCommand);
+program.addCommand(doctorCommand);
+program.addCommand(scanCommand);
+program.addCommand(configCommand);
+program.addCommand(fixCommand);
+program.parse(process.argv);
+//# sourceMappingURL=index.js.map