@kb-labs/qa-core 0.6.0

package/dist/runner/index.js

@@ -0,0 +1,713 @@
+import { existsSync, readFileSync, mkdirSync, writeFileSync, readdirSync, statSync } from 'fs';
+import { join, relative, dirname, resolve } from 'path';
+import { execSync, spawnSync } from 'child_process';
+import { createHash } from 'crypto';
+import { PATHS } from '@kb-labs/qa-contracts';
+
+// src/runner/workspace.ts
+function getSubmoduleInfo(repoDir, repoName) {
+  const gitDir = join(repoDir, ".git");
+  if (!existsSync(gitDir)) {
+    return null;
+  }
+  try {
+    const commit = execSync("git rev-parse --short HEAD", {
+      cwd: repoDir,
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const branch = execSync("git rev-parse --abbrev-ref HEAD", {
+      cwd: repoDir,
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const message = execSync("git log -1 --format=%s", {
+      cwd: repoDir,
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const statusOutput = execSync("git status --porcelain", {
+      cwd: repoDir,
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return {
+      name: repoName,
+      commit,
+      branch,
+      dirty: statusOutput.length > 0,
+      message
+    };
+  } catch {
+    return null;
+  }
+}
+function collectSubmoduleInfo(rootDir, repos) {
+  const result = {};
+  for (const repo of repos) {
+    const repoDir = join(rootDir, repo);
+    const info = getSubmoduleInfo(repoDir, repo);
+    if (info) {
+      result[repo] = info;
+    }
+  }
+  return result;
+}
+
+// src/runner/workspace.ts
+function hasWorkspace(dir) {
+  return existsSync(join(dir, "pnpm-workspace.yaml"));
+}
+function isDir(p) {
+  return existsSync(p) && statSync(p).isDirectory();
+}
+function buildCandidatesFromConfig(rootDir, paths) {
+  const candidates = [];
+  for (const pattern of paths) {
+    const parts = pattern.split("/");
+    if (parts.length === 2 && parts[1] === "*" && parts[0]) {
+      const categoryDir = join(rootDir, parts[0]);
+      if (!isDir(categoryDir)) {
+        continue;
+      }
+      try {
+        for (const sub of readdirSync(categoryDir)) {
+          if (sub.startsWith(".") || sub === "node_modules") {
+            continue;
+          }
+          const subPath = join(categoryDir, sub);
+          if (isDir(subPath) && hasWorkspace(subPath)) {
+            candidates.push(subPath);
+          }
+        }
+      } catch {
+      }
+    } else {
+      const exactPath = join(rootDir, pattern);
+      if (isDir(exactPath) && hasWorkspace(exactPath)) {
+        candidates.push(exactPath);
+      }
+    }
+  }
+  return candidates;
+}
+function buildCandidatesAutoScan(rootDir) {
+  const candidates = [];
+  for (const entry of readdirSync(rootDir)) {
+    if (entry.startsWith(".") || entry === "node_modules" || entry === "dist") {
+      continue;
+    }
+    const entryPath = join(rootDir, entry);
+    if (!isDir(entryPath)) {
+      continue;
+    }
+    if (hasWorkspace(entryPath)) {
+      candidates.push(entryPath);
+    } else {
+      try {
+        for (const sub of readdirSync(entryPath)) {
+          if (sub.startsWith(".") || sub === "node_modules") {
+            continue;
+          }
+          const subPath = join(entryPath, sub);
+          if (isDir(subPath) && hasWorkspace(subPath)) {
+            candidates.push(subPath);
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  return candidates;
+}
+function scanSubDir(parentDir, entryPath, repoName, rootDir, submodule, packages) {
+  if (!isDir(parentDir)) {
+    return;
+  }
+  for (const pkgDir of readdirSync(parentDir)) {
+    const pkgPath = join(parentDir, pkgDir);
+    const pkgJsonPath = join(pkgPath, "package.json");
+    if (!existsSync(pkgJsonPath)) {
+      continue;
+    }
+    try {
+      const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+      packages.push({
+        name: pkgJson.name || pkgDir,
+        dir: pkgPath,
+        relativePath: relative(rootDir, pkgPath),
+        repo: repoName,
+        submodule
+      });
+    } catch {
+    }
+  }
+}
+function getWorkspacePackages(rootDir, filter, packagesConfig) {
+  const packages = [];
+  const submoduleCache = /* @__PURE__ */ new Map();
+  function getSubmoduleCached(entryPath, repoName) {
+    if (!submoduleCache.has(repoName)) {
+      submoduleCache.set(repoName, getSubmoduleInfo(entryPath, repoName));
+    }
+    return submoduleCache.get(repoName) ?? void 0;
+  }
+  const candidates = packagesConfig?.paths && packagesConfig.paths.length > 0 ? buildCandidatesFromConfig(rootDir, packagesConfig.paths) : buildCandidatesAutoScan(rootDir);
+  for (const entryPath of candidates) {
+    const repoName = relative(rootDir, entryPath);
+    const submodule = getSubmoduleCached(entryPath, repoName);
+    scanSubDir(join(entryPath, "packages"), entryPath, repoName, rootDir, submodule, packages);
+    scanSubDir(join(entryPath, "apps"), entryPath, repoName, rootDir, submodule, packages);
+  }
+  let filtered = packages;
+  if (packagesConfig?.include && packagesConfig.include.length > 0) {
+    filtered = filtered.filter(
+      (pkg) => packagesConfig.include.some((pattern) => matchesPattern(pkg.name, pkg.repo, pattern))
+    );
+  }
+  if (packagesConfig?.exclude && packagesConfig.exclude.length > 0) {
+    filtered = filtered.filter(
+      (pkg) => !packagesConfig.exclude.some((pattern) => matchesPattern(pkg.name, pkg.repo, pattern))
+    );
+  }
+  if (!filter) {
+    return filtered;
+  }
+  return filtered.filter((pkg) => {
+    if (filter.package && !pkg.name.includes(filter.package)) {
+      return false;
+    }
+    if (filter.repo && pkg.repo !== filter.repo) {
+      return false;
+    }
+    if (filter.scope) {
+      const scope = filter.scope.startsWith("@") ? filter.scope : `@${filter.scope}`;
+      if (!pkg.name.startsWith(scope)) {
+        return false;
+      }
+    }
+    return true;
+  });
+}
+function matchesPattern(name, repo, pattern) {
+  if (pattern.endsWith("/*")) {
+    const prefix = pattern.slice(0, -2);
+    return repo === prefix || repo.startsWith(prefix + "/");
+  }
+  if (pattern.endsWith("*")) {
+    return name.startsWith(pattern.slice(0, -1));
+  }
+  return name === pattern || repo === pattern;
+}
+function readWorkspaceDeps(pkgDir, workspaceNames) {
+  try {
+    const raw = readFileSync(join(pkgDir, "package.json"), "utf-8");
+    const pkgJson = JSON.parse(raw);
+    const allDeps = { ...pkgJson.dependencies, ...pkgJson.devDependencies };
+    return Object.keys(allDeps).filter((dep) => workspaceNames.has(dep));
+  } catch {
+    return [];
+  }
+}
+function buildDepGraph(packages) {
+  const nameMap = /* @__PURE__ */ new Map();
+  const workspaceNames = /* @__PURE__ */ new Set();
+  for (const pkg of packages) {
+    nameMap.set(pkg.name, pkg);
+    workspaceNames.add(pkg.name);
+  }
+  const inDegree = /* @__PURE__ */ new Map();
+  const dependents = /* @__PURE__ */ new Map();
+  for (const pkg of packages) {
+    inDegree.set(pkg.name, 0);
+    dependents.set(pkg.name, []);
+  }
+  for (const pkg of packages) {
+    const deps = readWorkspaceDeps(pkg.dir, workspaceNames);
+    inDegree.set(pkg.name, deps.length);
+    for (const dep of deps) {
+      dependents.get(dep).push(pkg.name);
+    }
+  }
+  return { nameMap, inDegree, dependents };
+}
+function computeBuildLayers(packages) {
+  if (packages.length === 0) {
+    return [];
+  }
+  const { nameMap, inDegree, dependents } = buildDepGraph(packages);
+  const layers = [];
+  const remaining = new Set(packages.map((p) => p.name));
+  while (remaining.size > 0) {
+    const layerNames = [];
+    for (const name of remaining) {
+      if ((inDegree.get(name) ?? 0) === 0) {
+        layerNames.push(name);
+      }
+    }
+    if (layerNames.length === 0) {
+      const circular = [...remaining].map((n) => nameMap.get(n)).filter(Boolean);
+      layers.push({ index: layers.length, packages: circular });
+      break;
+    }
+    layerNames.sort();
+    layers.push({ index: layers.length, packages: layerNames.map((n) => nameMap.get(n)) });
+    for (const name of layerNames) {
+      remaining.delete(name);
+      for (const dependent of dependents.get(name) ?? []) {
+        inDegree.set(dependent, (inDegree.get(dependent) ?? 0) - 1);
+      }
+    }
+  }
+  return layers;
+}
+function sortByBuildLayers(packages) {
+  return computeBuildLayers(packages).flatMap((l) => l.packages);
+}
+
+// src/runner/custom-check-runner.ts
+var ID_MAP = {
+  build: "build",
+  lint: "lint",
+  typecheck: "typeCheck",
+  "type-check": "typeCheck",
+  test: "test",
+  tests: "test"
+};
+function emptyResult() {
+  return { passed: [], failed: [], skipped: [], errors: {} };
+}
+function runCommand(command, args, cwd, timeoutMs) {
+  try {
+    const result = spawnSync(command, args, { cwd, timeout: timeoutMs, encoding: "utf-8", shell: false });
+    const stdout = result.stdout ?? "";
+    const stderr = result.stderr ?? "";
+    const exitCode = result.status ?? 1;
+    return { ok: exitCode === 0, stdout, stderr, exitCode };
+  } catch (e) {
+    return { ok: false, stdout: "", stderr: e.message ?? String(e), exitCode: 1 };
+  }
+}
+function evaluate(check, stdout, stderr, exitCode) {
+  if ((check.parser ?? "exitcode") === "json") {
+    try {
+      const parsed = JSON.parse(stdout);
+      return parsed.ok === true || parsed.success === true || parsed.status === "ok";
+    } catch {
+      return false;
+    }
+  }
+  return exitCode === 0;
+}
+function recordResult(bucket, key, passed, stdout, stderr, exitCode, canonicalId, onProgress, durationMs) {
+  if (passed) {
+    bucket.passed.push(key);
+    onProgress?.(canonicalId, key, "pass", durationMs);
+  } else {
+    bucket.failed.push(key);
+    bucket.errors[key] = stderr || stdout || `Exit code ${exitCode}`;
+    onProgress?.(canonicalId, key, "fail", durationMs);
+  }
+}
+function runInRepoRoot(check, canonicalId, resolvedArgs, rootDir, bucket, onProgress) {
+  const startMs = Date.now();
+  const { stderr, exitCode, stdout } = runCommand(check.command, resolvedArgs, rootDir, check.timeoutMs ?? 12e4);
+  recordResult(bucket, rootDir, evaluate(check, stdout, stderr, exitCode), stdout, stderr, exitCode, canonicalId, onProgress, Date.now() - startMs);
+}
+function runInScopePath(check, canonicalId, resolvedArgs, packages, rootDir, bucket, onProgress) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const pkg of packages) {
+    if (seen.has(pkg.repo)) {
+      continue;
+    }
+    seen.add(pkg.repo);
+    const scopeDir = resolve(rootDir, pkg.repo);
+    if (!existsSync(scopeDir)) {
+      continue;
+    }
+    const startMs = Date.now();
+    const { stderr, exitCode, stdout } = runCommand(check.command, resolvedArgs, scopeDir, check.timeoutMs ?? 12e4);
+    recordResult(bucket, pkg.repo, evaluate(check, stdout, stderr, exitCode), stdout, stderr, exitCode, canonicalId, onProgress, Date.now() - startMs);
+  }
+}
+function getPnpmScriptName(check) {
+  if (check.command !== "pnpm") {
+    return void 0;
+  }
+  const args = check.args ?? [];
+  if (args[0] === "run" && args[1]) {
+    return args[1];
+  }
+  return void 0;
+}
+function hasNpmScript(pkgDir, scriptName) {
+  try {
+    const pkgJson = JSON.parse(readFileSync(join(pkgDir, "package.json"), "utf-8"));
+    return typeof pkgJson?.scripts?.[scriptName] === "string";
+  } catch {
+    return false;
+  }
+}
+function runPerPackage(check, canonicalId, resolvedArgs, packages, bucket, onProgress) {
+  const sortedPackages = check.ordered ? sortByBuildLayers(packages) : packages;
+  const scriptName = getPnpmScriptName(check);
+  for (const pkg of sortedPackages) {
+    if (scriptName && !hasNpmScript(pkg.dir, scriptName)) {
+      bucket.skipped.push(pkg.name);
+      onProgress?.(canonicalId, pkg.name, "skip");
+      continue;
+    }
+    const startMs = Date.now();
+    const { stderr, exitCode, stdout } = runCommand(check.command, resolvedArgs, pkg.dir, check.timeoutMs ?? 12e4);
+    recordResult(bucket, pkg.name, evaluate(check, stdout, stderr, exitCode), stdout, stderr, exitCode, canonicalId, onProgress, Date.now() - startMs);
+  }
+}
+function runCustomChecks(checks, packages, rootDir, onProgress) {
+  const results = {};
+  for (const check of checks) {
+    const canonicalId = ID_MAP[check.id.toLowerCase()] ?? check.id;
+    if (!results[canonicalId]) {
+      results[canonicalId] = emptyResult();
+    }
+    const bucket = results[canonicalId];
+    const args = check.args ?? [];
+    const resolvedArgs = args.map(
+      (arg) => arg.match(/\.(sh|js|ts|mjs|cjs)$/) && !arg.startsWith("/") ? join(rootDir, arg) : arg
+    );
+    const runIn = check.runIn ?? "perPackage";
+    if (runIn === "repoRoot") {
+      runInRepoRoot(check, canonicalId, resolvedArgs, rootDir, bucket, onProgress);
+    } else if (runIn === "scopePath") {
+      runInScopePath(check, canonicalId, resolvedArgs, packages, rootDir, bucket, onProgress);
+    } else {
+      runPerPackage(check, canonicalId, resolvedArgs, packages, bucket, onProgress);
+    }
+  }
+  return results;
+}
+function loadCache(rootDir) {
+  const cachePath = join(rootDir, PATHS.CACHE);
+  if (!existsSync(cachePath)) {
+    return {};
+  }
+  try {
+    return JSON.parse(readFileSync(cachePath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveCache(rootDir, cache) {
+  const cachePath = join(rootDir, PATHS.CACHE);
+  const dir = dirname(cachePath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(cachePath, JSON.stringify(cache, null, 2));
+}
+function computePackageHash(pkgDir) {
+  const hash = createHash("sha256");
+  const pkgJsonPath = join(pkgDir, "package.json");
+  if (existsSync(pkgJsonPath)) {
+    hash.update(readFileSync(pkgJsonPath));
+  }
+  const srcDir = join(pkgDir, "src");
+  if (existsSync(srcDir)) {
+    hashDirectory(srcDir, hash);
+  }
+  return hash.digest("hex");
+}
+function hashDirectory(dir, hash) {
+  const entries = readdirSync(dir).sort();
+  for (const entry of entries) {
+    const fullPath = join(dir, entry);
+    const stat = statSync(fullPath);
+    if (stat.isDirectory()) {
+      hashDirectory(fullPath, hash);
+    } else if (stat.isFile()) {
+      hash.update(fullPath);
+      hash.update(readFileSync(fullPath));
+    }
+  }
+}
+function hasPackageChanged(pkgDir, pkgName, cache) {
+  const currentHash = computePackageHash(pkgDir);
+  const cached = cache[pkgName];
+  if (!cached) {
+    return true;
+  }
+  return cached.hash !== currentHash;
+}
+function updateCacheEntry(pkgDir, pkgName, cache) {
+  const hash = computePackageHash(pkgDir);
+  return {
+    ...cache,
+    [pkgName]: { hash, timestamp: (/* @__PURE__ */ new Date()).toISOString() }
+  };
+}
+function needsRebuild(pkgDir) {
+  const srcDir = join(pkgDir, "src");
+  const distDir = join(pkgDir, "dist");
+  if (!existsSync(distDir)) {
+    return true;
+  }
+  if (!existsSync(srcDir)) {
+    return false;
+  }
+  const srcMtime = getLatestMtime(srcDir);
+  const distMtime = getLatestMtime(distDir);
+  return srcMtime > distMtime;
+}
+function getLatestMtime(dir) {
+  let latest = 0;
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        latest = Math.max(latest, getLatestMtime(fullPath));
+      } else {
+        latest = Math.max(latest, statSync(fullPath).mtimeMs);
+      }
+    }
+  } catch {
+  }
+  return latest;
+}
+function runBuildCheck(options) {
+  const { packages, noCache, onProgress } = options;
+  const result = { passed: [], failed: [], skipped: [], errors: {} };
+  const sorted = sortByBuildLayers(packages);
+  for (const pkg of sorted) {
+    if (!noCache && !needsRebuild(pkg.dir)) {
+      result.skipped.push(pkg.name);
+      onProgress?.(pkg.name, "skip");
+      continue;
+    }
+    const startMs = Date.now();
+    try {
+      execSync("pnpm run build", {
+        cwd: pkg.dir,
+        encoding: "utf-8",
+        timeout: 12e4,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      const durationMs = Date.now() - startMs;
+      result.passed.push(pkg.name);
+      onProgress?.(pkg.name, "pass", durationMs);
+    } catch (err) {
+      const durationMs = Date.now() - startMs;
+      result.failed.push(pkg.name);
+      const rawErr = (err.stderr || err.stdout || err.message || "").trim();
+      result.errors[pkg.name] = rawErr.slice(0, 2e3) || `Build failed (exit code ${err.status ?? 1})`;
+      onProgress?.(pkg.name, "fail", durationMs);
+    }
+  }
+  return result;
+}
+function runLintCheck(options) {
+  const { packages, onProgress } = options;
+  const result = { passed: [], failed: [], skipped: [], errors: {} };
+  for (const pkg of packages) {
+    const srcDir = join(pkg.dir, "src");
+    if (!existsSync(srcDir)) {
+      result.skipped.push(pkg.name);
+      onProgress?.(pkg.name, "skip");
+      continue;
+    }
+    const startMs = Date.now();
+    try {
+      execSync("pnpm exec eslint .", {
+        cwd: pkg.dir,
+        encoding: "utf-8",
+        timeout: 6e4,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      result.passed.push(pkg.name);
+      onProgress?.(pkg.name, "pass", Date.now() - startMs);
+    } catch (err) {
+      result.failed.push(pkg.name);
+      const rawErr = (err.stdout || err.stderr || err.message || "").trim();
+      result.errors[pkg.name] = rawErr.slice(0, 2e3) || `Lint failed (exit code ${err.status ?? 1})`;
+      onProgress?.(pkg.name, "fail", Date.now() - startMs);
+    }
+  }
+  return result;
+}
+function runTypeCheck(options) {
+  const { packages, onProgress } = options;
+  const result = { passed: [], failed: [], skipped: [], errors: {} };
+  for (const pkg of packages) {
+    const tsconfigPath = join(pkg.dir, "tsconfig.json");
+    if (!existsSync(tsconfigPath)) {
+      result.skipped.push(pkg.name);
+      onProgress?.(pkg.name, "skip");
+      continue;
+    }
+    const startMs = Date.now();
+    try {
+      execSync("pnpm exec tsc --noEmit", {
+        cwd: pkg.dir,
+        encoding: "utf-8",
+        timeout: 12e4,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      result.passed.push(pkg.name);
+      onProgress?.(pkg.name, "pass", Date.now() - startMs);
+    } catch (err) {
+      result.failed.push(pkg.name);
+      const rawErr = (err.stdout || err.stderr || err.message || "").trim();
+      result.errors[pkg.name] = rawErr.slice(0, 2e3) || `Type check failed (exit code ${err.status ?? 1})`;
+      onProgress?.(pkg.name, "fail", Date.now() - startMs);
+    }
+  }
+  return result;
+}
+function runTestCheck(options) {
+  const { packages, onProgress } = options;
+  const result = { passed: [], failed: [], skipped: [], errors: {} };
+  for (const pkg of packages) {
+    let pkgJson;
+    try {
+      pkgJson = JSON.parse(
+        readFileSync(join(pkg.dir, "package.json"), "utf-8")
+      );
+    } catch {
+      result.skipped.push(pkg.name);
+      onProgress?.(pkg.name, "skip");
+      continue;
+    }
+    if (!pkgJson.scripts?.test) {
+      result.skipped.push(pkg.name);
+      onProgress?.(pkg.name, "skip");
+      continue;
+    }
+    const startMs = Date.now();
+    try {
+      execSync("pnpm run test", {
+        cwd: pkg.dir,
+        encoding: "utf-8",
+        timeout: 12e4,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      result.passed.push(pkg.name);
+      onProgress?.(pkg.name, "pass", Date.now() - startMs);
+    } catch (err) {
+      result.failed.push(pkg.name);
+      const rawErr = (err.stdout || err.stderr || err.message || "").trim();
+      result.errors[pkg.name] = rawErr.slice(0, 2e3) || `Test failed (exit code ${err.status ?? 1})`;
+      onProgress?.(pkg.name, "fail", Date.now() - startMs);
+    }
+  }
+  return result;
+}
+function saveLastRun(rootDir, results, packages, submodules) {
+  const filePath = join(rootDir, PATHS.LAST_RUN);
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  const data = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    results,
+    packages: packages.map((p) => ({
+      name: p.name,
+      dir: p.dir,
+      relativePath: p.relativePath,
+      repo: p.repo,
+      submodule: p.submodule
+    })),
+    submodules
+  };
+  writeFileSync(filePath, JSON.stringify(data, null, 2));
+}
+function loadLastRun(rootDir) {
+  const filePath = join(rootDir, PATHS.LAST_RUN);
+  if (!existsSync(filePath)) {
+    return null;
+  }
+  try {
+    return JSON.parse(readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+// src/runner/qa-orchestrator.ts
+var SKIP_ALIASES = {
+  types: "typecheck",
+  "type-check": "typecheck",
+  tests: "test"
+};
+function runBuiltinChecks(options, packages, skipSet, results) {
+  const { rootDir, noCache } = options;
+  if (!skipSet.has("build")) {
+    results.build = runBuildCheck({
+      packages,
+      noCache,
+      onProgress: (pkg, status, durationMs) => options.onProgress?.("build", pkg, status, durationMs)
+    });
+  }
+  if (!skipSet.has("lint")) {
+    results.lint = runLintCheck({
+      packages,
+      onProgress: (pkg, status, durationMs) => options.onProgress?.("lint", pkg, status, durationMs)
+    });
+  }
+  if (!skipSet.has("typecheck")) {
+    results.typeCheck = runTypeCheck({
+      packages,
+      onProgress: (pkg, status, durationMs) => options.onProgress?.("typeCheck", pkg, status, durationMs)
+    });
+  }
+  if (!skipSet.has("test")) {
+    results.test = runTestCheck({
+      packages,
+      onProgress: (pkg, status, durationMs) => options.onProgress?.("test", pkg, status, durationMs)
+    });
+  }
+}
+async function runQA(options) {
+  const { rootDir, noCache } = options;
+  const skipSet = new Set(
+    (options.skipChecks ?? []).map((s) => SKIP_ALIASES[s.toLowerCase()] ?? s.toLowerCase())
+  );
+  const filter = { package: options.package, repo: options.repo, scope: options.scope };
+  const packages = getWorkspacePackages(rootDir, filter, options.packagesConfig);
+  let cache = noCache ? {} : loadCache(rootDir);
+  const results = {};
+  if (options.checks && options.checks.length > 0) {
+    const activeChecks = skipSet.size > 0 ? options.checks.filter((c) => !skipSet.has(c.id.toLowerCase())) : options.checks;
+    Object.assign(results, runCustomChecks(
+      activeChecks,
+      packages,
+      rootDir,
+      (checkId, pkg, status, durationMs) => {
+        options.onProgress?.(checkId, pkg, status, durationMs);
+      }
+    ));
+  } else {
+    runBuiltinChecks(options, packages, skipSet, results);
+  }
+  if (!noCache) {
+    for (const pkg of packages) {
+      cache = updateCacheEntry(pkg.dir, pkg.name, cache);
+    }
+    saveCache(rootDir, cache);
+  }
+  const submodules = {};
+  for (const pkg of packages) {
+    if (pkg.submodule && !submodules[pkg.repo]) {
+      submodules[pkg.repo] = pkg.submodule;
+    }
+  }
+  saveLastRun(rootDir, results, packages, Object.keys(submodules).length > 0 ? submodules : void 0);
+  return { results, packages };
+}
+
+export { collectSubmoduleInfo, computePackageHash, getSubmoduleInfo, getWorkspacePackages, hasPackageChanged, loadCache, loadLastRun, runBuildCheck, runLintCheck, runQA, runTestCheck, runTypeCheck, saveCache, saveLastRun, updateCacheEntry };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map