ai-test-cli 0.1.0

package/dist/commands/fix.js

@@ -0,0 +1,1207 @@
+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";
+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;
+  }
+}
+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 } from "path";
+function detectProjectInfo(targetDir = process.cwd()) {
+  const packageJsonPath = resolve(targetDir, "package.json");
+  const tsconfigPath = resolve(targetDir, "tsconfig.json");
+  let packageJson = {};
+  if (existsSync(packageJsonPath)) {
+    try {
+      packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    } catch (e) {
+    }
+  }
+  const allDeps = {
+    ...packageJson.dependencies || {},
+    ...packageJson.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(resolve(targetDir, "pnpm-lock.yaml"))) packageManager = "pnpm";
+  else if (existsSync(resolve(targetDir, "yarn.lock"))) packageManager = "yarn";
+  else if (existsSync(resolve(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/runner.ts
+import { exec } from "child_process";
+import { promisify } 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 execAsync(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 execAsync;
+var init_runner = __esm({
+  "src/core/runner.ts"() {
+    "use strict";
+    execAsync = promisify(exec);
+  }
+});
+
+// src/core/scanner.ts
+var scanner_exports = {};
+__export(scanner_exports, {
+  generateWorkspaceMap: () => generateWorkspaceMap,
+  scanDependencies: () => scanDependencies
+});
+import { Project } from "ts-morph";
+import { existsSync as existsSync2, readFileSync as readFileSync2, statSync } from "fs";
+import { resolve as resolve2, dirname } from "path";
+import fg 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 = resolve2(baseDir, cleanedSpecifier);
+  try {
+    const exactPath = resolve2(baseDir, moduleSpecifier);
+    if (existsSync2(exactPath) && statSync(exactPath).isFile()) {
+      return exactPath;
+    }
+  } catch (e) {
+  }
+  for (const ext of exts) {
+    const withExt = fullPath + ext;
+    try {
+      if (existsSync2(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 = readFileSync2(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 = [
+      resolve2(process.cwd(), "prisma/schema.prisma"),
+      resolve2(process.cwd(), "schema.prisma")
+    ];
+    for (const p of possiblePrismaPaths) {
+      if (existsSync2(p)) {
+        const content = readFileSync2(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 fg([
+      "**/*.{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/commands/generate.ts
+import { Command } from "commander";
+import { exec as exec2 } from "child_process";
+import { promisify as promisify2 } from "util";
+import { readFileSync as readFileSync3, writeFileSync, existsSync as existsSync3 } from "fs";
+import { resolve as resolve3, relative, dirname as dirname2, basename, extname } from "path";
+import fg2 from "fast-glob";
+import chalk2 from "chalk";
+async function generateTestForFile(filePath, config2, projectInfo, forceUpdate = false, evaluateExisting = false, workspaceMap = "") {
+  const relPath = relative(process.cwd(), filePath);
+  const dir = dirname2(filePath);
+  const ext = extname(filePath);
+  const name = basename(filePath, ext);
+  const testFilePath = resolve3(dir, `${name}.test${ext}`);
+  const spinner = logger.spinner(`Analyzing ${relPath}...`).start();
+  if (existsSync3(testFilePath) && !forceUpdate) {
+    spinner.info(`Evaluating existing test file for missing coverage: ${relPath}`);
+    evaluateExisting = true;
+  }
+  let fileContent = "";
+  try {
+    fileContent = readFileSync3(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 (existsSync3(testFilePath)) {
+    const existingCode = readFileSync3(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";
+    }
+    writeFileSync(testFilePath, testCode, "utf-8");
+    spinner.stop();
+    return "generated";
+  } catch (error) {
+    spinner.fail(`Error generating test for ${relPath}: ${error.message}`);
+    return "failed";
+  }
+}
+var execAsync2, generateCommand;
+var init_generate = __esm({
+  "src/commands/generate.ts"() {
+    "use strict";
+    init_config();
+    init_logger();
+    init_detector();
+    init_ai();
+    init_scanner();
+    execAsync2 = promisify2(exec2);
+    generateCommand = new Command("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 execAsync2(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 = resolve3(process.cwd(), file);
+              if (existsSync3(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 fg2(["**/*.{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 = resolve3(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(chalk2.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(chalk2.cyan("\u{1F680} " + terminalLink("Share your win on Twitter!", tweetUrl)));
+          console.log(chalk2.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 = resolve3(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(chalk2.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(chalk2.cyan("\u{1F680} " + terminalLink("Share your win on Twitter!", tweetUrl)));
+          console.log(chalk2.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/core/agentic.ts
+import { exec as exec3 } from "child_process";
+import { promisify as promisify3 } from "util";
+import { writeFileSync as writeFileSync2, readFileSync as readFileSync4, existsSync as existsSync4, readdirSync } from "fs";
+import { resolve as resolve4, dirname as dirname3 } from "path";
+import chalk3 from "chalk";
+var execAsync3, AgenticPlanner;
+var init_agentic = __esm({
+  "src/core/agentic.ts"() {
+    "use strict";
+    init_ai();
+    init_runner();
+    init_generate();
+    execAsync3 = promisify3(exec3);
+    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 = readFileSync4(sourceFilePath, "utf-8");
+          fileLength = content.length;
+          isMassive = fileLength > 2e4;
+        } catch (e) {
+        }
+        let initialResult = "failed";
+        if (isMassive) {
+          console.log(chalk3.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 = readFileSync4(sourceFilePath, "utf-8").split("\n");
+        } catch (e) {
+          return "failed";
+        }
+        if (existsSync4(testFilePath)) {
+          testCode = readFileSync4(testFilePath, "utf-8");
+        } else {
+          writeFileSync2(testFilePath, testCode, "utf-8");
+        }
+        console.log(chalk3.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(chalk3.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(chalk3.red(`\u2716 AI generated the exact same action 3 times in a row. Forcibly breaking loop.`));
+              break;
+            }
+          } else {
+            duplicateCount = 0;
+            previousStepsHash = currentStepsHash;
+          }
+          console.log(chalk3.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(chalk3.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(chalk3.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(chalk3.cyan(`  - \u{1F4DD} Appending test code chunk`));
+              testCode += "\n" + step.code;
+              writeFileSync2(testFilePath, testCode, "utf-8");
+              history.push(`Attempt ${attempts}: Appended test code.`);
+              madeProgress = true;
+            } else if (step.action === "finish") {
+              console.log(chalk3.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(chalk3.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(chalk3.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(chalk3.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 = readFileSync4(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(chalk3.green(`
+\u2714 AI successfully fixed the test for ${fileLabel} after ${attempts - 1} attempt(s)!`));
+            } else {
+              console.log(chalk3.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(chalk3.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(chalk3.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(chalk3.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(chalk3.red(`\u2716 AI generated the exact same exploration action consecutively. Forcibly breaking loop.`));
+                break;
+              }
+            } else {
+              duplicateCount = 0;
+              previousStepsHash = currentStepsHash;
+            }
+            console.log(chalk3.cyan(`\u{1F916} AI returned a plan:`));
+            if (plan.reasoning) {
+              console.log(chalk3.gray(`  \u{1F914} Reasoning: ${plan.reasoning}`));
+            }
+            let needsToBreakAndRunTests = false;
+            for (const step of plan.steps) {
+              if (step.action === "read_file") {
+                console.log(chalk3.cyan(`  - \u{1F4D6} Reading file: ${step.path}`));
+                try {
+                  const content = readFileSync4(resolve4(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(chalk3.cyan(`  - \u{1F50D} Searching for "${step.query}" in ${step.file}`));
+                try {
+                  const content = readFileSync4(resolve4(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(chalk3.cyan(`  - \u{1F4D6} Reading lines ${step.startLine}-${step.endLine} from ${step.file}`));
+                try {
+                  const content = readFileSync4(resolve4(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(chalk3.cyan(`  - \u{1F4C2} Listing directory: ${step.path}`));
+                try {
+                  const files = readdirSync(resolve4(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(chalk3.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(chalk3.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(chalk3.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(chalk3.cyan(`  - \u{1F6D1} Abort: ${step.reason}`));
+                history.push(`Attempt ${attempts}: Aborted with reason: ${step.reason}`);
+                if (sourceFilePath) {
+                  const bugFile = resolve4(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(chalk3.yellow(`  \u26A0 Issue logged to aitest-bugs.md for later fixing.`));
+                }
+              }
+            }
+            if (needsToBreakAndRunTests) {
+              const execResult = await this._executePlan(plan);
+              if (execResult === "abort") {
+                console.log(chalk3.red(`\u2716 AI plan execution aborted.`));
+                return "skipped";
+              }
+              planExecuted = true;
+            } else {
+              await new Promise((r) => setTimeout(r, 500));
+            }
+          }
+          if (!planExecuted) {
+            console.log(chalk3.red(`\u2716 AI exhausted exploration limit without applying a patch. Giving up on this file.`));
+            return "failed";
+          }
+          if (existsSync4(testFilePath)) {
+            testCode = readFileSync4(testFilePath, "utf-8");
+          }
+        }
+        console.log(chalk3.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 = dirname3(sourceFilePath);
+        return resolve4(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 = readFileSync4(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(chalk3.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 = resolve4(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) ? readFileSync4(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);
+              writeFileSync2(step.file, lines.join("\n"), "utf-8");
+              break;
+            }
+            case "install_deps": {
+              const deps = step.deps.join(" ");
+              try {
+                await execAsync3(`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/fix.ts
+init_config();
+init_logger();
+init_detector();
+init_ai();
+import { Command as Command2 } from "commander";
+import { exec as exec4 } from "child_process";
+import { promisify as promisify4 } from "util";
+import { existsSync as existsSync5 } from "fs";
+import { resolve as resolve5, dirname as dirname4, basename as basename2, extname as extname2 } from "path";
+import chalk4 from "chalk";
+var execAsync4 = promisify4(exec4);
+var fixCommand = new Command2("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 execAsync4(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 = resolve5(process.cwd(), failingFile);
+    if (!existsSync5(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 = [
+      resolve5(dir, `${name}.ts`),
+      resolve5(dir, `${name}.js`),
+      resolve5(dir, `${name}.tsx`),
+      resolve5(dir, `${name}.jsx`),
+      resolve5(dir, `../${name}.ts`),
+      // one level up might work
+      resolve5(dir, `../${name}.js`)
+    ];
+    let sourceAbsPath = void 0;
+    for (const sf of possibleSourceFiles) {
+      if (existsSync5(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);
+  }
+});
+export {
+  fixCommand
+};
+//# sourceMappingURL=fix.js.map