@rpcbase/test 0.308.0 → 0.310.0

package/dist/cli.js

@@ -0,0 +1,785 @@
+#!/usr/bin/env node
+import { spawn, spawnSync } from "node:child_process";
+import fs$1 from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import fg from "fast-glob";
+import { createCoverageConfig } from "./coverage/config.js";
+import { createCollectCoverageMatcher, resolveCollectCoverageRoots, isInsideAnyRoot } from "./coverage/collect.js";
+import { loadCoverageOptions } from "./coverage/config-loader.js";
+import { removeCoverageFiles } from "./coverage/files.js";
+import { CoverageThresholdError, collectCoveredFiles, generateCoverageReport } from "./coverage/report.js";
+const require$1 = createRequire(import.meta.url);
+const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+const VITEST_COVERAGE_CANDIDATES = ["src/coverage.json"];
+const COMBINED_COVERAGE_ENV_VAR = "RB_TEST_COMBINED_COVERAGE";
+const isAider = process.env.IS_AIDER === "yes";
+if (process.env.IS_AIDER !== void 0 && process.env.IS_AIDER !== "yes") {
+  console.warn("Warning: IS_AIDER is set to a value other than 'yes'.");
+}
+async function runTests() {
+  const userArgs = process.argv.slice(2);
+  const buildSpecsMap = userArgs.includes("--build-specs-map");
+  const auto = userArgs.includes("--auto");
+  const showMapping = userArgs.includes("--show-mapping");
+  const filteredArgs = userArgs.filter((arg) => arg !== "--build-specs-map" && arg !== "--auto" && arg !== "--show-mapping");
+  if (buildSpecsMap && auto) {
+    throw new Error("[rb-test] --auto cannot be combined with --build-specs-map");
+  }
+  if (showMapping && !auto) {
+    throw new Error("[rb-test] --show-mapping requires --auto");
+  }
+  const playwrightCoverage = await loadPlaywrightCoverageConfig();
+  const vitestCoverage = await loadVitestCoverageConfig();
+  const combinedCoverage = resolveCombinedCoverage(playwrightCoverage, vitestCoverage);
+  if (buildSpecsMap) {
+    await buildSpecsMapFromCoverage({
+      userArgs: filteredArgs,
+      combinedCoverage
+    });
+    return;
+  }
+  const shouldGenerateCoverageReport = combinedCoverage?.enabled && !auto;
+  if (shouldGenerateCoverageReport) {
+    await cleanCoverageArtifacts(combinedCoverage.config);
+  }
+  let testError = null;
+  try {
+    await runVitest(vitestCoverage, combinedCoverage?.config ?? null, { disableCoverage: auto });
+    console.log("\nRunning Playwright Tests...");
+    const playwrightArgs = auto ? await resolveAutoPlaywrightArgs({
+      userArgs: filteredArgs,
+      playwrightCoverage,
+      vitestCoverage,
+      showMapping
+    }) : userArgs;
+    if (playwrightArgs) {
+      await runPlaywright(playwrightArgs, { disableCoverage: auto });
+    }
+  } catch (error) {
+    testError = error;
+  }
+  if (shouldGenerateCoverageReport) {
+    try {
+      await finalizeCoverage(combinedCoverage.config);
+    } catch (error) {
+      if (!testError) {
+        testError = error;
+      }
+    }
+  }
+  if (testError) {
+    throw testError;
+  }
+}
+runTests().then(() => process.exit(0)).catch((error) => {
+  if (!(error instanceof CoverageThresholdError)) {
+    console.error(error?.stack ?? String(error));
+  }
+  process.exit(1);
+});
+async function runVitest(coverage, combinedConfig, { disableCoverage = false } = {}) {
+  const vitestArgs = ["run", "--passWithNoTests"];
+  const vitestConfig = resolveVitestConfig();
+  if (vitestConfig) {
+    vitestArgs.push("--config", vitestConfig);
+  }
+  const launcher = resolveVitestLauncher();
+  const env = withRegisterShim(process.env);
+  if (disableCoverage) {
+    env.RB_DISABLE_COVERAGE = "1";
+  }
+  if (coverage?.enabled && !disableCoverage) {
+    env.NODE_V8_COVERAGE = resolveNodeCoverageDir(combinedConfig ?? coverage.config);
+  }
+  await spawnWithLogs({
+    name: "Vitest",
+    launcher,
+    args: vitestArgs,
+    env,
+    successMessage: "Vitest suite passed!",
+    failureMessage: "Vitest failed"
+  });
+  if (coverage?.enabled && !disableCoverage) {
+    await convertNodeCoverage({
+      config: combinedConfig ?? coverage.config,
+      nodeCoverageDir: resolveNodeCoverageDir(combinedConfig ?? coverage.config)
+    });
+  }
+}
+async function buildSpecsMapFromCoverage({
+  userArgs,
+  combinedCoverage
+}) {
+  if (!combinedCoverage?.enabled) {
+    throw new Error("[specs-map] Coverage must be enabled to build the specs map.");
+  }
+  const config = combinedCoverage.config;
+  const workspaceRoot = findWorkspaceRoot(process.cwd());
+  const specSourceFiles = await findSpecSourceFiles(config.rootDir);
+  if (specSourceFiles.length === 0) {
+    throw new Error("[specs-map] No spec files found under spec/**/*.spec.ts");
+  }
+  const filesMapDir = path.join(config.testResultsRoot, "files-map");
+  await fs.rm(filesMapDir, { recursive: true, force: true });
+  await fs.mkdir(filesMapDir, { recursive: true });
+  for (const specSourceFile of specSourceFiles) {
+    const specProjectPath = path.relative(config.rootDir, specSourceFile);
+    const specWorkspacePath = toPosixPath(path.relative(workspaceRoot, specSourceFile));
+    const testFile = resolvePlaywrightSpecFile(specProjectPath);
+    console.log(`
+[specs-map] Running ${specWorkspacePath}`);
+    await removeCoverageFiles(config);
+    let error = null;
+    let failed = false;
+    try {
+      await runPlaywright([...userArgs, testFile]);
+    } catch (runError) {
+      error = runError;
+      failed = true;
+      console.error(`[specs-map] Failed: ${specWorkspacePath}`);
+      console.error(runError?.stack ?? String(runError));
+    }
+    const coveredFiles = await collectCoveredFiles(config);
+    const impactedFiles = coveredFiles.map((filePath) => toPosixPath(path.relative(workspaceRoot, filePath))).filter((relativePath) => relativePath && !relativePath.startsWith("../") && relativePath !== "..").sort();
+    const outputFile = path.join(filesMapDir, `${specProjectPath}.json`);
+    await fs.mkdir(path.dirname(outputFile), { recursive: true });
+    await fs.writeFile(
+      outputFile,
+      JSON.stringify(
+        {
+          spec: specWorkspacePath,
+          files: impactedFiles,
+          failed
+        },
+        null,
+        2
+      ),
+      "utf8"
+    );
+    if (failed) {
+      throw error;
+    }
+  }
+}
+async function resolveAutoPlaywrightArgs({
+  userArgs,
+  playwrightCoverage,
+  vitestCoverage,
+  showMapping = false
+}) {
+  const config = playwrightCoverage?.config ?? vitestCoverage?.config ?? null;
+  if (!config) {
+    console.warn("[auto] Coverage config not found; running full Playwright suite.");
+    return userArgs;
+  }
+  const filesMapDir = path.join(config.testResultsRoot, "files-map");
+  const mapFiles = await findFilesMapJson(filesMapDir);
+  if (mapFiles.length === 0) {
+    console.warn("[auto] Specs map not found; running full Playwright suite.");
+    return userArgs;
+  }
+  const workspaceRoot = findWorkspaceRoot(process.cwd());
+  const gitChanges = getGitChanges(workspaceRoot);
+  const renameMap = new Map(
+    gitChanges.filter((change) => change.kind === "rename").map((change) => [change.oldPath, change.newPath])
+  );
+  const specRootAbs = path.join(config.rootDir, "spec");
+  const matchesCollectCoverageFrom = createCollectCoverageMatcher(config.collectCoverageFrom, config.rootDir);
+  const directSpecChanges = /* @__PURE__ */ new Set();
+  const sourceChanges = [];
+  for (const change of gitChanges) {
+    if (change.kind === "rename") {
+      const oldAbs = path.join(workspaceRoot, change.oldPath);
+      const newAbs = path.join(workspaceRoot, change.newPath);
+      if (isSpecSourceFile(newAbs, specRootAbs) && fs$1.existsSync(newAbs)) {
+        directSpecChanges.add(change.newPath);
+      }
+      const oldMatches = matchesCollectCoverageFrom(oldAbs);
+      const newMatches = matchesCollectCoverageFrom(newAbs);
+      if (oldMatches || newMatches) {
+        sourceChanges.push(change);
+      }
+      continue;
+    }
+    const abs = path.join(workspaceRoot, change.path);
+    if (isSpecSourceFile(abs, specRootAbs) && fs$1.existsSync(abs)) {
+      directSpecChanges.add(change.path);
+    }
+    if (matchesCollectCoverageFrom(abs)) {
+      sourceChanges.push(change);
+    }
+  }
+  if (directSpecChanges.size === 0 && sourceChanges.length === 0) {
+    console.log("[auto] No relevant git changes.");
+    return null;
+  }
+  const parsedMaps = [];
+  for (const file of mapFiles) {
+    const json = await readJson(file);
+    if (!json) {
+      continue;
+    }
+    if (json.failed === true) {
+      console.warn("[auto] Specs map contains failed entries; running full Playwright suite.");
+      return userArgs;
+    }
+    const spec = typeof json?.spec === "string" ? json.spec : null;
+    if (!spec) {
+      continue;
+    }
+    const files = Array.isArray(json?.files) ? json.files.filter((entry) => typeof entry === "string") : [];
+    parsedMaps.push({ spec, files });
+  }
+  if (parsedMaps.length === 0) {
+    console.warn("[auto] Specs map is empty; running full Playwright suite.");
+    return userArgs;
+  }
+  const specsByImpactedFile = /* @__PURE__ */ new Map();
+  for (const entry of parsedMaps) {
+    const resolvedSpec = resolveRenamedPath(entry.spec, renameMap);
+    for (const file of entry.files) {
+      const list = specsByImpactedFile.get(file) ?? [];
+      list.push(resolvedSpec);
+      specsByImpactedFile.set(file, list);
+    }
+  }
+  const unmappedSourceChanges = sourceChanges.filter((change) => {
+    if (change.kind === "path") {
+      return !specsByImpactedFile.has(change.path);
+    }
+    return !specsByImpactedFile.has(change.oldPath) && !specsByImpactedFile.has(change.newPath);
+  });
+  if (unmappedSourceChanges.length > 0) {
+    console.warn("[auto] Unmapped source changes detected:");
+    for (const change of unmappedSourceChanges) {
+      if (change.kind === "path") {
+        console.warn(`  - ${change.path}`);
+      } else {
+        console.warn(`  - ${change.oldPath} -> ${change.newPath}`);
+      }
+    }
+  }
+  const selectedSpecs = new Set(directSpecChanges);
+  const triggersBySpec = /* @__PURE__ */ new Map();
+  for (const spec of directSpecChanges) {
+    if (showMapping) {
+      triggersBySpec.set(spec, /* @__PURE__ */ new Set([spec]));
+    }
+  }
+  for (const change of sourceChanges) {
+    if (change.kind === "path") {
+      const specs = specsByImpactedFile.get(change.path) ?? [];
+      specs.forEach((spec) => selectedSpecs.add(spec));
+      if (showMapping) {
+        for (const spec of specs) {
+          const current = triggersBySpec.get(spec) ?? /* @__PURE__ */ new Set();
+          current.add(change.path);
+          triggersBySpec.set(spec, current);
+        }
+      }
+      continue;
+    }
+    const oldSpecs = specsByImpactedFile.get(change.oldPath) ?? [];
+    oldSpecs.forEach((spec) => selectedSpecs.add(spec));
+    const newSpecs = specsByImpactedFile.get(change.newPath) ?? [];
+    newSpecs.forEach((spec) => selectedSpecs.add(spec));
+    if (showMapping) {
+      const key = `${change.oldPath} -> ${change.newPath}`;
+      const allSpecs = /* @__PURE__ */ new Set([...oldSpecs, ...newSpecs]);
+      for (const spec of allSpecs) {
+        const current = triggersBySpec.get(spec) ?? /* @__PURE__ */ new Set();
+        current.add(key);
+        triggersBySpec.set(spec, current);
+      }
+    }
+  }
+  const missingSpecs = [];
+  const specsToRun = Array.from(selectedSpecs).filter((spec) => {
+    const abs = path.join(workspaceRoot, spec);
+    if (fs$1.existsSync(abs)) {
+      return true;
+    }
+    missingSpecs.push(spec);
+    return false;
+  }).sort();
+  if (missingSpecs.length > 0) {
+    console.warn(`[auto] Ignoring ${missingSpecs.length} missing spec file(s):`);
+    for (const spec of missingSpecs.sort()) {
+      console.warn(`  - ${spec}`);
+    }
+  }
+  if (specsToRun.length === 0) {
+    console.log("[auto] No impacted specs.");
+    return null;
+  }
+  if (showMapping) {
+    console.log("[auto] Mapping:");
+    for (const spec of specsToRun) {
+      const triggers = Array.from(triggersBySpec.get(spec) ?? []).sort();
+      if (triggers.length === 0) {
+        continue;
+      }
+      console.log(`  - ${spec}`);
+      for (const trigger of triggers) {
+        console.log(`    <- ${trigger}`);
+      }
+    }
+  }
+  const playwrightFiles = specsToRun.map((specWorkspacePath) => path.join(workspaceRoot, specWorkspacePath)).filter((specAbs) => isSubpath(specAbs, config.rootDir)).map((specAbs) => {
+    const specProjectPath = path.relative(config.rootDir, specAbs);
+    return resolvePlaywrightSpecFile(specProjectPath);
+  });
+  const totalSpecFiles = (await findSpecSourceFiles(config.rootDir)).length;
+  console.log(`[auto] Running ${playwrightFiles.length}/${totalSpecFiles} spec file(s).`);
+  return [...userArgs, ...playwrightFiles];
+}
+async function findFilesMapJson(filesMapDir) {
+  const patterns = ["spec/**/*.spec.ts.json", "spec/**/*.spec.tsx.json"];
+  const matches = await fg(patterns, { cwd: filesMapDir, absolute: true, onlyFiles: true }).catch(() => []);
+  return matches.sort();
+}
+function getGitChanges(workspaceRoot) {
+  const result = spawnSync("git", ["status", "--porcelain=1", "-z"], {
+    cwd: workspaceRoot,
+    encoding: "utf8"
+  });
+  if (result.status !== 0) {
+    throw new Error(`[auto] Failed to read git status: ${result.stderr || "unknown error"}`);
+  }
+  const tokens = String(result.stdout ?? "").split("\0").filter(Boolean);
+  const changes = [];
+  for (let i = 0; i < tokens.length; i += 1) {
+    const record = tokens[i];
+    if (record.length < 4) {
+      continue;
+    }
+    const status = record.slice(0, 2);
+    const pathPart = toPosixPath(record.slice(3));
+    if (isRenameOrCopyStatus(status)) {
+      const next = tokens[i + 1];
+      if (typeof next !== "string") {
+        continue;
+      }
+      changes.push({
+        kind: "rename",
+        oldPath: pathPart,
+        newPath: toPosixPath(next)
+      });
+      i += 1;
+      continue;
+    }
+    changes.push({
+      kind: "path",
+      path: pathPart
+    });
+  }
+  return changes;
+}
+function isRenameOrCopyStatus(status) {
+  return status.includes("R") || status.includes("C");
+}
+function resolveRenamedPath(original, renameMap) {
+  let current = original;
+  const visited = /* @__PURE__ */ new Set();
+  while (!visited.has(current)) {
+    const next = renameMap.get(current);
+    if (!next) {
+      break;
+    }
+    visited.add(current);
+    current = next;
+  }
+  return current;
+}
+function isSubpath(candidate, root) {
+  const relative = path.relative(root, candidate);
+  return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function isSpecSourceFile(absolutePath, specRootAbsolute) {
+  if (!isSubpath(absolutePath, specRootAbsolute)) {
+    return false;
+  }
+  return absolutePath.endsWith(".spec.ts") || absolutePath.endsWith(".spec.tsx");
+}
+async function findSpecSourceFiles(projectRoot) {
+  const patterns = ["spec/**/*.spec.ts", "spec/**/*.spec.tsx"];
+  const matches = await fg(patterns, { cwd: projectRoot, absolute: true, onlyFiles: true });
+  return matches.sort();
+}
+function resolvePlaywrightSpecFile(specProjectPath) {
+  const buildSpecRoot = path.join(process.cwd(), "build", "spec");
+  const isBuildSpecProject = fs$1.existsSync(buildSpecRoot);
+  if (!isBuildSpecProject) {
+    return specProjectPath;
+  }
+  const builtCandidate = normalizeBuiltSpecPath(path.join("build", specProjectPath));
+  const builtAbsolute = path.resolve(process.cwd(), builtCandidate);
+  if (!fs$1.existsSync(builtAbsolute)) {
+    throw new Error(`[specs-map] Missing built spec file: ${builtCandidate}`);
+  }
+  return builtCandidate;
+}
+function normalizeBuiltSpecPath(filePath) {
+  if (filePath.endsWith(".ts") || filePath.endsWith(".tsx")) {
+    return `${filePath.replace(/\.tsx?$/, "")}.js`;
+  }
+  return filePath;
+}
+function toPosixPath(input) {
+  return String(input ?? "").split(path.sep).join("/");
+}
+function findWorkspaceRoot(projectRoot) {
+  let dir = path.resolve(projectRoot);
+  while (true) {
+    const pkgPath = path.join(dir, "package.json");
+    try {
+      if (fs$1.existsSync(pkgPath)) {
+        const parsed = JSON.parse(fs$1.readFileSync(pkgPath, "utf8"));
+        if (parsed && typeof parsed === "object" && parsed.workspaces) {
+          return dir;
+        }
+      }
+    } catch {
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) {
+      return path.resolve(projectRoot);
+    }
+    dir = parent;
+  }
+}
+function runPlaywright(userArgs, { disableCoverage = false } = {}) {
+  const configPath = fs$1.existsSync(
+    path.join(process.cwd(), "playwright.config.ts")
+  ) ? path.join(process.cwd(), "playwright.config.ts") : path.join(moduleDir, "playwright.config.ts");
+  const hasCustomConfig = userArgs.some((arg) => {
+    if (arg === "--config" || arg === "-c") {
+      return true;
+    }
+    return arg.startsWith("--config=");
+  });
+  const playwrightArgs = ["test"];
+  if (!hasCustomConfig) {
+    playwrightArgs.push("--config", configPath);
+  }
+  playwrightArgs.push(...userArgs);
+  ensureJsxRuntimeShim(process.cwd());
+  const launcher = resolvePlaywrightLauncher();
+  const env = withRegisterShim(process.env);
+  env[COMBINED_COVERAGE_ENV_VAR] = "1";
+  if (disableCoverage) {
+    env.RB_DISABLE_COVERAGE = "1";
+  }
+  return spawnWithLogs({
+    name: "Playwright",
+    launcher,
+    args: playwrightArgs,
+    env,
+    successMessage: "Playwright suite passed!",
+    failureMessage: "Playwright failed"
+  });
+}
+function resolvePlaywrightLauncher() {
+  const cliPath = resolveCliPath();
+  if (cliPath) {
+    return {
+      command: process.execPath,
+      args: [cliPath]
+    };
+  }
+  const localBin = path.resolve(process.cwd(), "node_modules/.bin/playwright");
+  if (fs$1.existsSync(localBin)) {
+    return {
+      command: localBin,
+      args: []
+    };
+  }
+  return {
+    command: "playwright",
+    args: []
+  };
+}
+function resolveCliPath() {
+  const searchRoots = [process.cwd(), moduleDir];
+  for (const base of searchRoots) {
+    try {
+      const pkgPath = require$1.resolve("@playwright/test/package.json", { paths: [base] });
+      const cliPath = path.join(path.dirname(pkgPath), "cli.js");
+      if (fs$1.existsSync(cliPath)) {
+        return cliPath;
+      }
+    } catch (_error) {
+    }
+  }
+  return null;
+}
+function resolveVitestLauncher() {
+  const searchRoots = [process.cwd(), moduleDir];
+  for (const base of searchRoots) {
+    try {
+      const pkgPath = require$1.resolve("vitest/package.json", { paths: [base] });
+      const pkgDir = path.dirname(pkgPath);
+      const pkgJson = JSON.parse(fs$1.readFileSync(pkgPath, "utf8"));
+      const binPath = typeof pkgJson.bin === "string" ? pkgJson.bin : pkgJson.bin?.vitest;
+      if (binPath) {
+        return {
+          command: process.execPath,
+          args: [path.join(pkgDir, binPath)]
+        };
+      }
+    } catch (_error) {
+    }
+  }
+  const localBin = path.resolve(process.cwd(), "node_modules/.bin/vitest");
+  if (fs$1.existsSync(localBin)) {
+    return {
+      command: localBin,
+      args: []
+    };
+  }
+  return {
+    command: "vitest",
+    args: []
+  };
+}
+function resolveVitestConfig() {
+  const userConfig = findVitestConfig(process.cwd());
+  if (userConfig) {
+    return userConfig;
+  }
+  const bundledConfig = path.join(moduleDir, "vitest.config.js");
+  return fs$1.existsSync(bundledConfig) ? bundledConfig : null;
+}
+function findVitestConfig(baseDir) {
+  const candidates = [
+    "vitest.config.ts",
+    "vitest.config.js",
+    "vitest.config.mjs"
+  ];
+  for (const file of candidates) {
+    const fullPath = path.join(baseDir, file);
+    if (fs$1.existsSync(fullPath)) {
+      return fullPath;
+    }
+  }
+  return null;
+}
+async function loadVitestCoverageConfig() {
+  const options = await loadCoverageOptions({
+    optional: true,
+    candidates: VITEST_COVERAGE_CANDIDATES,
+    defaultTestResultsDir: "test-results-vitest"
+  });
+  if (!options) {
+    return null;
+  }
+  const config = createCoverageConfig(options);
+  return {
+    config,
+    enabled: config.coverageEnabled
+  };
+}
+async function loadPlaywrightCoverageConfig() {
+  const options = await loadCoverageOptions({ optional: true });
+  if (!options) {
+    return null;
+  }
+  const config = createCoverageConfig(options);
+  return {
+    config,
+    enabled: config.coverageEnabled
+  };
+}
+function resolveCombinedCoverage(playwrightCoverage, vitestCoverage) {
+  if (playwrightCoverage?.enabled) {
+    return playwrightCoverage;
+  }
+  if (vitestCoverage?.enabled) {
+    return vitestCoverage;
+  }
+  return null;
+}
+async function cleanCoverageArtifacts(config) {
+  await removeCoverageFiles(config);
+  await fs.rm(config.coverageReportDir, { recursive: true, force: true });
+  await fs.rm(path.join(config.testResultsRoot, "node-coverage"), { recursive: true, force: true });
+}
+function resolveNodeCoverageDir(config) {
+  return path.join(config.testResultsRoot, "node-coverage", "vitest");
+}
+async function convertNodeCoverage(coverage) {
+  const { config, nodeCoverageDir } = coverage;
+  const entries = await fs.readdir(nodeCoverageDir).catch(() => []);
+  const scripts = [];
+  const scriptRoots = resolveCollectCoverageRoots(config.collectCoverageFrom, config.rootDir);
+  for (const entry of entries) {
+    if (!entry.endsWith(".json")) {
+      continue;
+    }
+    const fullPath = path.join(nodeCoverageDir, entry);
+    const payload = await readJson(fullPath);
+    const results = Array.isArray(payload?.result) ? payload.result : [];
+    for (const script of results) {
+      const normalized = normalizeNodeScriptUrl(script.url, config.rootDir);
+      if (!normalized) {
+        continue;
+      }
+      if (isNodeModulesPath(normalized.absolutePath)) {
+        continue;
+      }
+      if (!isInsideAnyRoot(normalized.absolutePath, scriptRoots)) {
+        continue;
+      }
+      const source = await fs.readFile(normalized.absolutePath, "utf8").catch(() => "");
+      scripts.push({
+        absolutePath: normalized.absolutePath,
+        relativePath: normalized.relativePath,
+        source,
+        functions: script.functions ?? [],
+        url: script.url
+      });
+    }
+  }
+  if (scripts.length === 0) {
+    return;
+  }
+  const outDir = path.join(config.testResultsRoot, "vitest");
+  await fs.mkdir(outDir, { recursive: true });
+  const outputFile = path.join(outDir, config.coverageFileName);
+  await fs.writeFile(outputFile, JSON.stringify({ testId: "vitest", scripts }, null, 2), "utf8");
+}
+async function finalizeCoverage(config) {
+  try {
+    await generateCoverageReport(config);
+  } catch (error) {
+    if (error instanceof CoverageThresholdError) {
+      console.error(error.message);
+    }
+    throw error;
+  }
+}
+async function readJson(filePath) {
+  try {
+    const raw = await fs.readFile(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function normalizeNodeScriptUrl(rawUrl, rootDir) {
+  if (!rawUrl || rawUrl.startsWith("node:")) {
+    return null;
+  }
+  let absolutePath = null;
+  try {
+    if (rawUrl.startsWith("file://")) {
+      absolutePath = fileURLToPath(rawUrl);
+    }
+  } catch (_err) {
+  }
+  if (!absolutePath && path.isAbsolute(rawUrl)) {
+    absolutePath = rawUrl;
+  }
+  if (!absolutePath) {
+    return null;
+  }
+  const normalized = path.normalize(absolutePath);
+  return {
+    absolutePath: normalized,
+    relativePath: path.relative(rootDir, normalized)
+  };
+}
+function isNodeModulesPath(filePath) {
+  return path.normalize(String(filePath ?? "")).split(path.sep).includes("node_modules");
+}
+function spawnWithLogs({
+  name,
+  launcher,
+  args,
+  env,
+  successMessage,
+  failureMessage
+}) {
+  return new Promise((resolve, reject) => {
+    const stdoutBuffer = [];
+    const stderrBuffer = [];
+    const child = spawn(
+      launcher.command,
+      [...launcher.args || [], ...args],
+      {
+        shell: false,
+        env
+      }
+    );
+    child.stdout?.on("data", (data) => {
+      if (!isAider) {
+        process.stdout.write(data);
+      }
+      stdoutBuffer.push(data.toString());
+    });
+    child.stderr?.on("data", (data) => {
+      if (!isAider) {
+        process.stderr.write(data);
+      }
+      stderrBuffer.push(data.toString());
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        if (successMessage) {
+          console.log(successMessage);
+        }
+        resolve();
+      } else {
+        console.error(failureMessage || `${name} failed:`);
+        if (isAider) {
+          if (stdoutBuffer.length > 0) {
+            console.error(stdoutBuffer.join(""));
+          }
+          if (stderrBuffer.length > 0) {
+            console.error(stderrBuffer.join(""));
+          }
+        }
+        reject(new Error(`${name} failed with exit code: ${code}`));
+      }
+    });
+    child.on("error", (error) => {
+      console.error(`Error spawning ${name}:`, error);
+      reject(error);
+    });
+  });
+}
+function withRegisterShim(baseEnv) {
+  const nodeOptions = appendNodeRequire(baseEnv.NODE_OPTIONS, path.join(moduleDir, "register-tty.cjs"));
+  return {
+    ...baseEnv,
+    NODE_OPTIONS: nodeOptions
+  };
+}
+function ensureJsxRuntimeShim(projectRoot) {
+  const shimDir = path.join(projectRoot, "node_modules", "playwright");
+  fs$1.mkdirSync(shimDir, { recursive: true });
+  const shims = [
+    { file: "jsx-runtime.js", target: "react/jsx-runtime" },
+    { file: "jsx-dev-runtime.js", target: "react/jsx-dev-runtime" }
+  ];
+  for (const { file, target } of shims) {
+    const filePath = path.join(shimDir, file);
+    if (!fs$1.existsSync(filePath)) {
+      const content = `export * from "${target}";
+export { default } from "${target}";
+`;
+      fs$1.writeFileSync(filePath, content, "utf8");
+    }
+  }
+}
+function appendNodeRequire(existing, modulePath) {
+  const flag = `--require=${modulePath}`;
+  if (!existing || existing.length === 0) {
+    return flag;
+  }
+  return `${existing} ${flag}`;
+}
+//# sourceMappingURL=cli.js.map