@kb-labs/qa-core 0.6.0

package/dist/index.js

@@ -0,0 +1,1550 @@
+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 { TRENDS_WINDOW, PATHS, HISTORY_MAX_ENTRIES, getCheckIcon, getCheckLabel } 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 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 };
+}
+function loadBaseline(rootDir) {
+  const path = join(rootDir, PATHS.BASELINE);
+  if (!existsSync(path)) {
+    return null;
+  }
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function saveBaseline(rootDir, snapshot) {
+  const path = join(rootDir, PATHS.BASELINE);
+  const dir = dirname(path);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(path, JSON.stringify(snapshot, null, 2));
+}
+function getGitInfo(rootDir) {
+  try {
+    const commit = execSync("git rev-parse --short HEAD", {
+      cwd: rootDir,
+      encoding: "utf-8"
+    }).trim();
+    const branch = execSync("git rev-parse --abbrev-ref HEAD", {
+      cwd: rootDir,
+      encoding: "utf-8"
+    }).trim();
+    return { commit, branch };
+  } catch {
+    return { commit: "unknown", branch: "unknown" };
+  }
+}
+function createBaselineFromResults(results, rootDir) {
+  const git = getGitInfo(rootDir);
+  const snapshot = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    git,
+    results: {}
+  };
+  for (const ct of Object.keys(results)) {
+    const r = results[ct];
+    snapshot.results[ct] = {
+      passed: r.passed.length,
+      failed: r.failed.length,
+      failedPackages: [...r.failed]
+    };
+  }
+  return snapshot;
+}
+async function captureBaseline(rootDir) {
+  const { results } = await runQA({ rootDir });
+  const snapshot = createBaselineFromResults(results, rootDir);
+  saveBaseline(rootDir, snapshot);
+  return snapshot;
+}
+
+// src/baseline/baseline-comparator.ts
+function compareWithBaseline(results, baseline) {
+  const diff = {};
+  const checkTypes = [.../* @__PURE__ */ new Set([...Object.keys(results), ...Object.keys(baseline.results)])];
+  for (const ct of checkTypes) {
+    const current = new Set(results[ct]?.failed ?? []);
+    const baselineFailed = new Set(baseline.results[ct]?.failedPackages ?? []);
+    const newFailures = [...current].filter((p) => !baselineFailed.has(p));
+    const fixed = [...baselineFailed].filter((p) => !current.has(p));
+    const stillFailing = [...current].filter((p) => baselineFailed.has(p));
+    diff[ct] = {
+      newFailures,
+      fixed,
+      stillFailing,
+      delta: current.size - baselineFailed.size
+    };
+  }
+  return diff;
+}
+function loadHistory(rootDir) {
+  const path = join(rootDir, PATHS.HISTORY);
+  if (!existsSync(path)) {
+    return [];
+  }
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function saveHistory(rootDir, entries) {
+  const path = join(rootDir, PATHS.HISTORY);
+  const dir = dirname(path);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(path, JSON.stringify(entries, null, 2));
+}
+function createHistoryEntry(results, rootDir, packages) {
+  let commit = "unknown";
+  let branch = "unknown";
+  let message = "";
+  try {
+    commit = execSync("git rev-parse --short HEAD", { cwd: rootDir, encoding: "utf-8" }).trim();
+    branch = execSync("git rev-parse --abbrev-ref HEAD", { cwd: rootDir, encoding: "utf-8" }).trim();
+    message = execSync("git log -1 --format=%s", { cwd: rootDir, encoding: "utf-8" }).trim();
+  } catch {
+  }
+  const hasFailures = Object.values(results).some((r) => r.failed.length > 0);
+  const summary = {};
+  const failedPackages = {};
+  for (const ct of Object.keys(results)) {
+    const r = results[ct];
+    summary[ct] = {
+      passed: r.passed.length,
+      failed: r.failed.length,
+      skipped: r.skipped.length
+    };
+    failedPackages[ct] = [...r.failed];
+  }
+  let submodules;
+  if (packages) {
+    const subs = {};
+    for (const pkg of packages) {
+      if (pkg.submodule && !subs[pkg.repo]) {
+        subs[pkg.repo] = pkg.submodule;
+      }
+    }
+    if (Object.keys(subs).length > 0) {
+      submodules = subs;
+    }
+  }
+  return {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    git: { commit, branch, message },
+    submodules,
+    status: hasFailures ? "failed" : "passed",
+    summary,
+    failedPackages
+  };
+}
+function appendEntry(rootDir, entry) {
+  const history = loadHistory(rootDir);
+  history.push(entry);
+  while (history.length > HISTORY_MAX_ENTRIES) {
+    history.shift();
+  }
+  saveHistory(rootDir, history);
+}
+function collectCheckTypes(entries) {
+  const s = /* @__PURE__ */ new Set();
+  for (const e of entries) {
+    for (const k of Object.keys(e.summary)) {
+      s.add(k);
+    }
+  }
+  return [...s];
+}
+function analyzeTrends(history, window = TRENDS_WINDOW) {
+  if (history.length < 2) {
+    return [];
+  }
+  const windowEntries = history.slice(-window);
+  const first = windowEntries[0];
+  const last = windowEntries[windowEntries.length - 1];
+  const results = [];
+  for (const ct of collectCheckTypes([first, last])) {
+    const previous = first.summary[ct]?.failed ?? 0;
+    const current = last.summary[ct]?.failed ?? 0;
+    const delta = current - previous;
+    let trend;
+    if (delta > 0) {
+      trend = "regression";
+    } else if (delta < 0) {
+      trend = "improvement";
+    } else {
+      trend = "no-change";
+    }
+    results.push({ checkType: ct, label: getCheckLabel(ct), icon: getCheckIcon(ct), previous, current, delta, trend });
+  }
+  return results;
+}
+function analyzeEnrichedTrends(history, window = TRENDS_WINDOW) {
+  if (history.length < 2) {
+    return [];
+  }
+  const windowEntries = history.slice(-window);
+  const first = windowEntries[0];
+  const last = windowEntries[windowEntries.length - 1];
+  const results = [];
+  for (const ct of collectCheckTypes(windowEntries)) {
+    const timeSeries = windowEntries.map((entry) => ({
+      timestamp: entry.timestamp,
+      gitCommit: entry.git.commit,
+      gitBranch: entry.git.branch,
+      gitMessage: entry.git.message,
+      passed: entry.summary[ct]?.passed ?? 0,
+      failed: entry.summary[ct]?.failed ?? 0,
+      skipped: entry.summary[ct]?.skipped ?? 0
+    }));
+    const changelog = [];
+    const deltas = [];
+    for (let i = 1; i < windowEntries.length; i++) {
+      const prev = windowEntries[i - 1];
+      const curr = windowEntries[i];
+      const prevFailed = new Set(prev.failedPackages[ct] ?? []);
+      const currFailed = curr.failedPackages[ct] ?? [];
+      const currFailedSet = new Set(currFailed);
+      const newFailures = currFailed.filter((p) => !prevFailed.has(p));
+      const fixed = [...prevFailed].filter((p) => !currFailedSet.has(p));
+      const delta2 = currFailed.length - prevFailed.size;
+      deltas.push(delta2);
+      if (newFailures.length > 0 || fixed.length > 0) {
+        changelog.push({
+          timestamp: curr.timestamp,
+          gitCommit: curr.git.commit,
+          gitMessage: curr.git.message,
+          newFailures,
+          fixed,
+          delta: delta2
+        });
+      }
+    }
+    const previous = first.summary[ct]?.failed ?? 0;
+    const current = last.summary[ct]?.failed ?? 0;
+    const delta = current - previous;
+    let trend;
+    if (delta > 0) {
+      trend = "regression";
+    } else if (delta < 0) {
+      trend = "improvement";
+    } else {
+      trend = "no-change";
+    }
+    const velocity = deltas.length > 0 ? deltas.reduce((sum, d) => sum + d, 0) / deltas.length : 0;
+    results.push({
+      checkType: ct,
+      label: getCheckLabel(ct),
+      icon: getCheckIcon(ct),
+      timeSeries,
+      changelog,
+      current,
+      previous,
+      delta,
+      trend,
+      velocity: Math.round(velocity * 100) / 100
+    });
+  }
+  return results;
+}
+
+// src/history/regression-detector.ts
+function detectRegressions(history) {
+  if (history.length < 2) {
+    return { hasRegressions: false, regressions: [] };
+  }
+  const previous = history[history.length - 2];
+  const current = history[history.length - 1];
+  const regressions = [];
+  const checkTypes = [.../* @__PURE__ */ new Set([...Object.keys(previous.failedPackages), ...Object.keys(current.failedPackages)])];
+  for (const ct of checkTypes) {
+    const prevFailed = new Set(previous.failedPackages[ct] ?? []);
+    const currFailed = current.failedPackages[ct] ?? [];
+    const newFailures = currFailed.filter((p) => !prevFailed.has(p));
+    const delta = currFailed.length - prevFailed.size;
+    if (newFailures.length > 0) {
+      regressions.push({
+        checkType: ct,
+        delta,
+        newFailures
+      });
+    }
+  }
+  return {
+    hasRegressions: regressions.length > 0,
+    regressions
+  };
+}
+
+// src/history/package-timeline.ts
+function buildEntries(history, packageName) {
+  let repo = "unknown";
+  const entries = [];
+  for (let i = history.length - 1; i >= 0; i--) {
+    const h = history[i];
+    const checks = {};
+    let found = false;
+    for (const ct of Object.keys(h.summary)) {
+      const failedList = h.failedPackages[ct] ?? [];
+      const summaryEntry = h.summary[ct];
+      if (failedList.includes(packageName)) {
+        checks[ct] = "failed";
+        found = true;
+      } else if (summaryEntry && (summaryEntry.passed > 0 || summaryEntry.failed > 0)) {
+        checks[ct] = "passed";
+        found = true;
+      } else {
+        checks[ct] = "skipped";
+      }
+    }
+    if (!found) {
+      continue;
+    }
+    let submoduleCommit;
+    if (h.submodules) {
+      for (const [repoName, info] of Object.entries(h.submodules)) {
+        if (repoName === repo || repo === "unknown") {
+          submoduleCommit = info.commit;
+          if (repo === "unknown") {
+            repo = repoName;
+          }
+        }
+      }
+    }
+    entries.push({
+      timestamp: h.timestamp,
+      git: h.git,
+      submoduleCommit,
+      checks
+    });
+  }
+  return { entries, repo };
+}
+function computeFlakyScore(entries) {
+  const allCheckTypes = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    for (const k of Object.keys(entry.checks)) {
+      allCheckTypes.add(k);
+    }
+  }
+  const flakyChecks = [];
+  let totalFlips = 0;
+  let totalTransitions = 0;
+  for (const ct of allCheckTypes) {
+    let flips = 0;
+    let transitions = 0;
+    for (let i = 1; i < entries.length; i++) {
+      const prev = entries[i - 1].checks[ct];
+      const curr = entries[i].checks[ct];
+      if (prev === "skipped" || curr === "skipped" || !prev || !curr) {
+        continue;
+      }
+      transitions++;
+      if (prev !== curr) {
+        flips++;
+      }
+    }
+    if (transitions > 0 && flips / transitions > 0.3) {
+      flakyChecks.push(ct);
+    }
+    totalFlips += flips;
+    totalTransitions += transitions;
+  }
+  return {
+    flakyScore: totalTransitions > 0 ? Math.min(1, totalFlips / totalTransitions) : 0,
+    flakyChecks
+  };
+}
+function computeStreak(entries) {
+  const latest = entries[0];
+  if (!latest) {
+    return { status: "passing", count: 0 };
+  }
+  const streakStatus = Object.values(latest.checks).some((v) => v === "failed") ? "failing" : "passing";
+  let count = 1;
+  for (let i = 1; i < entries.length; i++) {
+    const eFail = Object.values(entries[i].checks).some((v) => v === "failed");
+    if ((eFail ? "failing" : "passing") !== streakStatus) {
+      break;
+    }
+    count++;
+  }
+  return { status: streakStatus, count };
+}
+function getPackageTimeline(history, packageName) {
+  const { entries, repo } = buildEntries(history, packageName);
+  const { flakyScore, flakyChecks } = computeFlakyScore(entries);
+  let firstFailure;
+  for (let i = entries.length - 1; i >= 0; i--) {
+    if (Object.values(entries[i].checks).some((v) => v === "failed")) {
+      firstFailure = entries[i].timestamp;
+    }
+  }
+  return {
+    packageName,
+    repo,
+    entries,
+    flakyScore: Math.round(flakyScore * 100) / 100,
+    flakyChecks,
+    firstFailure,
+    currentStreak: computeStreak(entries)
+  };
+}
+
+// src/report/json-reporter.ts
+function buildJsonReport(results, diff) {
+  const hasFailures = Object.values(results).some((r) => r.failed.length > 0);
+  const summary = {};
+  const failures = {};
+  const errors = {};
+  for (const ct of Object.keys(results)) {
+    const r = results[ct];
+    const total = r.passed.length + r.failed.length + r.skipped.length;
+    summary[ct] = {
+      total,
+      passed: r.passed.length,
+      failed: r.failed.length,
+      skipped: r.skipped.length
+    };
+    failures[ct] = [...r.failed];
+    errors[ct] = { ...r.errors };
+  }
+  return {
+    status: hasFailures ? "failed" : "passed",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    summary,
+    failures,
+    errors,
+    baseline: diff ?? null
+  };
+}
+function buildDetailedJsonReport(results, grouped, diff) {
+  const base = buildJsonReport(results, diff);
+  return { ...base, grouped };
+}
+function icon(ct) {
+  return getCheckIcon(ct);
+}
+function label(ct) {
+  return getCheckLabel(ct);
+}
+function buildBaselineDiffLines(diff) {
+  const lines = [];
+  for (const ct of Object.keys(diff)) {
+    const d = diff[ct];
+    if (d.newFailures.length > 0) {
+      lines.push(`${icon(ct)} ${label(ct)}: +${d.newFailures.length} new failures`);
+      for (const pkg of d.newFailures) {
+        lines.push(`     - ${pkg}`);
+      }
+    }
+    if (d.fixed.length > 0) {
+      lines.push(`${icon(ct)} ${label(ct)}: -${d.fixed.length} fixed`);
+    }
+  }
+  return lines;
+}
+function buildRunReport(results, diff) {
+  const sections = [];
+  const summaryLines = [];
+  let totalPassed = 0;
+  let totalFailed = 0;
+  let totalSkipped = 0;
+  for (const ct of Object.keys(results)) {
+    const r = results[ct];
+    const total = r.passed.length + r.failed.length + r.skipped.length;
+    const pct = total > 0 ? Math.round(r.passed.length / total * 100) : 100;
+    const status = r.failed.length === 0 ? "PASS" : "FAIL";
+    summaryLines.push(`${status} ${icon(ct)}  ${label(ct).padEnd(12)} ${r.passed.length}/${total} passed (${pct}%)`);
+    if (r.failed.length > 0) {
+      for (const pkg of r.failed.slice(0, 5)) {
+        summaryLines.push(`     - ${pkg}`);
+      }
+      if (r.failed.length > 5) {
+        summaryLines.push(`     ... and ${r.failed.length - 5} more`);
+      }
+    }
+    totalPassed += r.passed.length;
+    totalFailed += r.failed.length;
+    totalSkipped += r.skipped.length;
+  }
+  sections.push({ header: "QA Summary Report", lines: summaryLines });
+  if (diff) {
+    const diffLines = buildBaselineDiffLines(diff);
+    if (diffLines.length > 0) {
+      sections.push({ header: "Baseline Comparison", lines: diffLines });
+    }
+  }
+  sections.push({
+    header: "Totals",
+    lines: [`Total: ${totalPassed} passed, ${totalFailed} failed, ${totalSkipped} skipped`]
+  });
+  return sections;
+}
+function buildHistoryTable(history, limit = 20) {
+  const entries = history.slice(-limit);
+  const lines = [];
+  for (const entry of entries) {
+    const date = new Date(entry.timestamp).toLocaleDateString();
+    const status = entry.status === "passed" ? "PASS" : "FAIL";
+    const summary = Object.keys(entry.summary).map((ct) => {
+      const s = entry.summary[ct];
+      return `${icon(ct)} ${s.failed}F`;
+    }).join(" ");
+    lines.push(`${date} ${entry.git.commit} ${status} ${summary} ${entry.git.message.slice(0, 40)}`);
+  }
+  return [{ header: `QA History (last ${entries.length})`, lines }];
+}
+function buildTrendsReport(trends, history) {
+  if (trends.length === 0) {
+    return [{ header: "QA Trends", lines: ["Not enough history (need at least 2 entries)"] }];
+  }
+  const lines = [];
+  for (const t of trends) {
+    const arrow = t.delta > 0 ? `+${t.delta} (regression)` : t.delta < 0 ? `${t.delta} (improvement)` : "\u2192 no change";
+    lines.push(`${icon(t.checkType)} ${label(t.checkType).padEnd(12)} ${t.previous} \u2192 ${t.current}  ${arrow}`);
+  }
+  if (history.length >= 2) {
+    const first = history[Math.max(0, history.length - 10)];
+    const last = history[history.length - 1];
+    lines.push("");
+    lines.push(`Period: ${new Date(first.timestamp).toLocaleDateString()} \u2192 ${new Date(last.timestamp).toLocaleDateString()}`);
+  }
+  return [{ header: "QA Trends", lines }];
+}
+function buildRegressionsReport(result, history) {
+  if (history.length < 2) {
+    return [{ header: "Regression Detection", lines: ["Not enough history (need at least 2 entries)"] }];
+  }
+  const prev = history[history.length - 2];
+  const curr = history[history.length - 1];
+  const lines = [
+    `Comparing: ${prev.git.commit} \u2192 ${curr.git.commit}`,
+    ""
+  ];
+  if (!result.hasRegressions) {
+    lines.push("No regressions detected.");
+    return [{ header: "Regression Detection", lines }];
+  }
+  for (const r of result.regressions) {
+    lines.push(`${r.checkType}: +${r.newFailures.length} new failures`);
+    for (const pkg of r.newFailures) {
+      lines.push(`  - ${pkg}`);
+    }
+  }
+  lines.push("");
+  lines.push("REGRESSIONS DETECTED!");
+  return [{ header: "Regression Detection", lines }];
+}
+function buildBaselineReport(baseline) {
+  if (!baseline) {
+    return [{ header: "Baseline Status", lines: ["No baseline captured yet. Run baseline:update first."] }];
+  }
+  const lines = [
+    `Captured: ${new Date(baseline.timestamp).toLocaleString()}`,
+    `Git: ${baseline.git.commit} (${baseline.git.branch})`,
+    ""
+  ];
+  for (const ct of Object.keys(baseline.results)) {
+    const r = baseline.results[ct];
+    lines.push(`${icon(ct)} ${label(ct).padEnd(12)} ${r.passed} passed, ${r.failed} failed`);
+    if (r.failedPackages.length > 0) {
+      const shown = r.failedPackages.slice(0, 3);
+      for (const pkg of shown) {
+        lines.push(`     - ${pkg}`);
+      }
+      if (r.failedPackages.length > 3) {
+        lines.push(`     ... and ${r.failedPackages.length - 3} more`);
+      }
+    }
+  }
+  return [{ header: "Baseline Status", lines }];
+}
+function checkTag(status, ct) {
+  const short = ct === "typeCheck" ? "types" : ct;
+  if (status === "failed") {
+    return short.toUpperCase();
+  }
+  if (status === "skipped") {
+    return `-${short}-`;
+  }
+  return short;
+}
+function getErrorPreview(raw) {
+  const errLines = raw.split("\n").filter((l) => l.trim().length > 0);
+  for (const el of errLines) {
+    const cleaned = el.replace(/^Command failed: .*/, "").trim();
+    if (cleaned.length > 0) {
+      return cleaned.replace(/\/[^\s]*\/kb-labs\//g, "").slice(0, 100);
+    }
+  }
+  return "";
+}
+function renderPackageLines(pkg, lines) {
+  const hasFail = Object.values(pkg.checks).some((v) => v === "failed");
+  const status = hasFail ? "FAIL" : "PASS";
+  const tags = Object.keys(pkg.checks).map((ct) => checkTag(pkg.checks[ct], ct)).join(" ");
+  lines.push(`    ${status} ${pkg.name.padEnd(40)} ${tags}`);
+  if (hasFail) {
+    for (const ct of Object.keys(pkg.checks)) {
+      if (pkg.checks[ct] === "failed") {
+        const preview = getErrorPreview((pkg.errors[ct] ?? "").trim());
+        lines.push(`         ${ct}: ${preview || "failed"}`);
+      }
+    }
+  }
+}
+function renderCategoryLines(catKey, grouped) {
+  const cat = grouped.categories[catKey];
+  const lines = [`PASS ${cat.summary.passed} | FAIL ${cat.summary.failed}`, ""];
+  for (const repoKey of Object.keys(cat.repos).sort()) {
+    const repo = cat.repos[repoKey];
+    lines.push(`  ${repoKey} (${repo.summary.total} packages)`);
+    const sorted = [...repo.packages].sort((a, b) => {
+      const aFail = Object.values(a.checks).some((v) => v === "failed") ? 0 : 1;
+      const bFail = Object.values(b.checks).some((v) => v === "failed") ? 0 : 1;
+      if (aFail !== bFail) {
+        return aFail - bFail;
+      }
+      return a.name.localeCompare(b.name);
+    });
+    for (const pkg of sorted) {
+      renderPackageLines(pkg, lines);
+    }
+    lines.push("");
+  }
+  return lines;
+}
+function buildDetailedRunReport(grouped, diff) {
+  const sections = [];
+  const categoryKeys = Object.keys(grouped.categories).sort((a, b) => {
+    if (a === "uncategorized") {
+      return 1;
+    }
+    if (b === "uncategorized") {
+      return -1;
+    }
+    return a.localeCompare(b);
+  });
+  for (const catKey of categoryKeys) {
+    const cat = grouped.categories[catKey];
+    sections.push({ header: `${cat.label} (${cat.summary.total} packages)`, lines: renderCategoryLines(catKey, grouped) });
+  }
+  if (diff) {
+    const diffLines = buildBaselineDiffLines(diff);
+    if (diffLines.length > 0) {
+      sections.push({ header: "Baseline Comparison", lines: diffLines });
+    }
+  }
+  let totalPassed = 0;
+  let totalFailed = 0;
+  for (const catKey of categoryKeys) {
+    totalPassed += grouped.categories[catKey].summary.passed;
+    totalFailed += grouped.categories[catKey].summary.failed;
+  }
+  sections.push({
+    header: "Totals",
+    lines: [`Total: ${totalPassed} passed, ${totalFailed} failed (${categoryKeys.length} categories)`]
+  });
+  return sections;
+}
+
+// src/report/grouped-reporter.ts
+function emptyGroupSummary(checkTypes) {
+  const checks = {};
+  for (const ct of checkTypes) {
+    checks[ct] = { passed: 0, failed: 0, skipped: 0 };
+  }
+  return { total: 0, passed: 0, failed: 0, checks };
+}
+function resolveCheckStatus(pkgName, ct, results) {
+  const r = results[ct];
+  if (!r) {
+    return "skipped";
+  }
+  if (r.failed.includes(pkgName)) {
+    return "failed";
+  }
+  if (r.passed.includes(pkgName)) {
+    return "passed";
+  }
+  return "skipped";
+}
+function buildPackageStatus(pkg, results, category) {
+  const checks = {};
+  const errors = {};
+  for (const ct of Object.keys(results)) {
+    checks[ct] = resolveCheckStatus(pkg.name, ct, results);
+    if (checks[ct] === "failed" && results[ct]?.errors[pkg.name]) {
+      errors[ct] = results[ct].errors[pkg.name];
+    }
+  }
+  return {
+    name: pkg.name,
+    repo: pkg.repo,
+    category,
+    checks,
+    errors
+  };
+}
+function addToSummary(summary, status) {
+  summary.total++;
+  const hasFail = Object.values(status.checks).some((v) => v === "failed");
+  if (hasFail) {
+    summary.failed++;
+  } else {
+    summary.passed++;
+  }
+  for (const ct of Object.keys(status.checks)) {
+    const s = status.checks[ct];
+    if (!summary.checks[ct]) {
+      summary.checks[ct] = { passed: 0, failed: 0, skipped: 0 };
+    }
+    if (s === "passed") {
+      summary.checks[ct].passed++;
+    } else if (s === "failed") {
+      summary.checks[ct].failed++;
+    } else {
+      summary.checks[ct].skipped++;
+    }
+  }
+}
+function groupResults(results, packages, categoryMap, config) {
+  const checkTypes = Object.keys(results);
+  const grouped = { categories: {} };
+  for (const pkg of packages) {
+    const categoryKeys = categoryMap.get(pkg.name) ?? ["uncategorized"];
+    for (const categoryKey of categoryKeys) {
+      const status = buildPackageStatus(pkg, results, categoryKey);
+      if (!grouped.categories[categoryKey]) {
+        const label2 = categoryKey === "uncategorized" ? "Uncategorized" : config?.categories?.[categoryKey]?.label ?? categoryKey;
+        grouped.categories[categoryKey] = {
+          label: label2,
+          repos: {},
+          summary: emptyGroupSummary(checkTypes)
+        };
+      }
+      const categoryGroup = grouped.categories[categoryKey];
+      if (!categoryGroup.repos[pkg.repo]) {
+        categoryGroup.repos[pkg.repo] = {
+          packages: [],
+          summary: emptyGroupSummary(checkTypes)
+        };
+      }
+      const repoGroup = categoryGroup.repos[pkg.repo];
+      repoGroup.packages.push(status);
+      addToSummary(repoGroup.summary, status);
+      addToSummary(categoryGroup.summary, status);
+    }
+  }
+  return grouped;
+}
+
+// src/report/error-grouping.ts
+function extractPattern(errorText, checkType) {
+  if (checkType === "lint") {
+    const ruleMatch = errorText.match(/(\S+\/[\w-]+|no-[\w-]+)/);
+    if (ruleMatch?.[1]) {
+      return ruleMatch[1];
+    }
+  }
+  if (checkType === "typeCheck") {
+    const tsMatch = errorText.match(/TS(\d{4,5})/);
+    if (tsMatch) {
+      return `TS${tsMatch[1]}`;
+    }
+  }
+  if (checkType === "test") {
+    const failMatch = errorText.match(/FAIL\s+(\S+)/);
+    if (failMatch) {
+      return `FAIL: ${failMatch[1]}`;
+    }
+  }
+  if (checkType === "build") {
+    if (errorText.includes("Cannot find module")) {
+      return "Cannot find module";
+    }
+    if (errorText.includes("Module not found")) {
+      return "Module not found";
+    }
+  }
+  const firstLine = errorText.split("\n").find((l) => l.trim().length > 0)?.trim() ?? "";
+  return firstLine.slice(0, 100) || "Unknown error";
+}
+function groupErrors(results) {
+  const groupMap = /* @__PURE__ */ new Map();
+  let ungrouped = 0;
+  for (const ct of Object.keys(results)) {
+    const check = results[ct];
+    if (!check.errors) {
+      continue;
+    }
+    for (const [pkgName, errorText] of Object.entries(check.errors)) {
+      const pattern = extractPattern(errorText, ct);
+      const key = `${ct}::${pattern}`;
+      const existing = groupMap.get(key);
+      if (existing) {
+        existing.count++;
+        existing.packages.push(pkgName);
+      } else {
+        groupMap.set(key, {
+          pattern,
+          count: 1,
+          packages: [pkgName],
+          checkType: ct,
+          example: errorText.slice(0, 200)
+        });
+      }
+    }
+  }
+  const groups = [];
+  for (const group of groupMap.values()) {
+    if (group.count === 1) {
+      ungrouped++;
+    } else {
+      groups.push(group);
+    }
+  }
+  groups.sort((a, b) => b.count - a.count);
+  return { groups, ungrouped };
+}
+
+// src/categories/category-resolver.ts
+function matchesPattern2(packageName, repo, pattern) {
+  if (pattern.includes("/") && pattern.endsWith("/*")) {
+    const repoPrefix = pattern.slice(0, -2);
+    return repo === repoPrefix;
+  }
+  if (!pattern.includes("*")) {
+    return packageName === pattern;
+  }
+  const prefix = pattern.slice(0, pattern.indexOf("*"));
+  return packageName.startsWith(prefix);
+}
+function resolveCategories(packages, config) {
+  const map = /* @__PURE__ */ new Map();
+  if (!config?.categories) {
+    for (const pkg of packages) {
+      map.set(pkg.name, ["uncategorized"]);
+    }
+    return map;
+  }
+  const categoryEntries = Object.entries(config.categories);
+  for (const pkg of packages) {
+    const matched = [];
+    for (const [categoryKey, categoryConfig] of categoryEntries) {
+      for (const pattern of categoryConfig.packages) {
+        if (matchesPattern2(pkg.name, pkg.repo, pattern)) {
+          matched.push(categoryKey);
+          break;
+        }
+      }
+    }
+    map.set(pkg.name, matched.length > 0 ? matched : ["uncategorized"]);
+  }
+  return map;
+}
+
+export { analyzeEnrichedTrends, analyzeTrends, appendEntry, buildBaselineReport, buildDetailedJsonReport, buildDetailedRunReport, buildHistoryTable, buildJsonReport, buildRegressionsReport, buildRunReport, buildTrendsReport, captureBaseline, collectSubmoduleInfo, compareWithBaseline, createBaselineFromResults, createHistoryEntry, detectRegressions, getPackageTimeline, getSubmoduleInfo, getWorkspacePackages, groupErrors, groupResults, loadBaseline, loadHistory, loadLastRun, resolveCategories, runLintCheck, runQA, runTestCheck, runTypeCheck, saveBaseline, saveHistory, saveLastRun };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map