@yuu1111/quality-check 0.5.1 → 0.7.0

package/dist/cli.js

@@ -0,0 +1,861 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/cli.ts
+import { tmpdir } from "os";
+import { join as join2, resolve as resolve2 } from "path";
+
+// ../shared/src/baseline.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+
+// ../shared/src/json.ts
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// ../shared/src/baseline.ts
+function entryKey(entry) {
+  return [entry.engine ?? "", entry.rule, entry.file, entry.text].join("\x00");
+}
+function compareEntries(left, right) {
+  const leftKey = entryKey(left);
+  const rightKey = entryKey(right);
+  if (leftKey === rightKey) {
+    return 0;
+  }
+  return leftKey < rightKey ? -1 : 1;
+}
+function toEntry(finding) {
+  const entry = {
+    count: 1,
+    file: finding.file,
+    rule: finding.rule,
+    text: finding.text
+  };
+  if (finding.engine !== undefined) {
+    entry.engine = finding.engine;
+  }
+  return entry;
+}
+function createBaseline(findings) {
+  const entries = new Map;
+  for (const finding of findings) {
+    const key = entryKey(finding);
+    const existing = entries.get(key);
+    if (existing) {
+      existing.count += 1;
+      continue;
+    }
+    entries.set(key, toEntry(finding));
+  }
+  return { entries: [...entries.values()].sort(compareEntries), version: 1 };
+}
+function compareWithBaseline(findings, baseline) {
+  const remaining = new Map;
+  for (const entry of baseline.entries) {
+    const key = entryKey(entry);
+    remaining.set(key, (remaining.get(key) ?? 0) + entry.count);
+  }
+  const added = [];
+  for (const finding of findings) {
+    const key = entryKey(finding);
+    const count = remaining.get(key) ?? 0;
+    if (count > 0) {
+      remaining.set(key, count - 1);
+      continue;
+    }
+    added.push(finding);
+  }
+  const resolved = baseline.entries.filter((entry) => (remaining.get(entryKey(entry)) ?? 0) > 0);
+  return { added, resolved };
+}
+function isBaselineEntry(value) {
+  if (!isJsonObject(value)) {
+    return false;
+  }
+  return (value.engine === undefined || typeof value.engine === "string") && typeof value.file === "string" && typeof value.rule === "string" && typeof value.text === "string" && typeof value.count === "number";
+}
+function readBaseline(path, label) {
+  if (!existsSync(path)) {
+    return { entries: [], version: 1 };
+  }
+  const value = JSON.parse(readFileSync(path, "utf8"));
+  if (!isJsonObject(value) || !Array.isArray(value.entries) || !value.entries.every(isBaselineEntry)) {
+    throw new Error(`${path} is not a ${label} baseline`);
+  }
+  return { entries: value.entries, version: 1 };
+}
+function writeBaseline(path, baseline) {
+  writeFileSync(path, `${JSON.stringify(baseline, null, "\t")}
+`);
+}
+
+// ../shared/src/cli.ts
+function addValue(values, name, value) {
+  const list = values.get(name);
+  if (list === undefined) {
+    values.set(name, [value]);
+    return;
+  }
+  list.push(value);
+}
+function addTarget(targets, argument) {
+  if (argument.startsWith("-")) {
+    throw new Error(`unknown option: ${argument}`);
+  }
+  targets.push(argument);
+}
+function optionName(argument) {
+  const separator = argument.indexOf("=");
+  return separator === -1 ? argument.slice(2) : argument.slice(2, separator);
+}
+function inlineValue(argument) {
+  const separator = argument.indexOf("=");
+  return separator === -1 ? undefined : argument.slice(separator + 1);
+}
+function consumeValue(values, argv, index, name) {
+  const value = argv[index + 1];
+  if (value === undefined) {
+    return 0;
+  }
+  addValue(values, name, value);
+  return 1;
+}
+function parseArgv(argv, spec) {
+  const flags = new Set;
+  const values = new Map;
+  const valueNames = new Set(spec.values ?? []);
+  const flagNames = new Set(spec.flags ?? []);
+  const targets = [];
+  for (let index = 0;index < argv.length; index += 1) {
+    const argument = argv[index] ?? "";
+    if (!argument.startsWith("--")) {
+      addTarget(targets, argument);
+      continue;
+    }
+    const name = optionName(argument);
+    if (valueNames.has(name)) {
+      const inline = inlineValue(argument);
+      if (inline !== undefined) {
+        addValue(values, name, inline);
+        continue;
+      }
+      index += consumeValue(values, argv, index, name);
+      continue;
+    }
+    if (flagNames.has(name) && argument.indexOf("=") === -1) {
+      flags.add(name);
+      continue;
+    }
+    throw new Error(`unknown option: ${argument}`);
+  }
+  return { flags, targets, values };
+}
+function wantsHelp(argv) {
+  return argv.includes("--help") || argv.includes("-h");
+}
+function runCli(main) {
+  async function execute() {
+    try {
+      process.exit(await main(process.argv.slice(2)));
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : String(error));
+      process.exit(2);
+    }
+  }
+  execute();
+}
+
+// ../shared/src/color.ts
+var ANSI_CODES = {
+  error: "31",
+  header: "36",
+  muted: "2",
+  pass: "32",
+  warn: "33"
+};
+function plainPainter(text, _tone) {
+  return text;
+}
+function ansiPainter() {
+  return (text, tone) => `\x1B[${ANSI_CODES[tone]}m${text}\x1B[0m`;
+}
+function colorEnabled(stream, env) {
+  if (env.NO_COLOR !== undefined && env.NO_COLOR !== "") {
+    return false;
+  }
+  if (env.FORCE_COLOR !== undefined && env.FORCE_COLOR !== "") {
+    return env.FORCE_COLOR !== "0";
+  }
+  return stream.isTTY === true;
+}
+
+// src/config.ts
+import { existsSync as existsSync2 } from "fs";
+import { resolve } from "path";
+import { pathToFileURL } from "url";
+var ENGINE_NAMES = [
+  "biome",
+  "typecheck",
+  "knip",
+  "comment-check",
+  "document-style-check",
+  "tsdoc-check"
+];
+var DEFAULT_CONFIG_FILES = [
+  "quality.config.ts",
+  "quality.config.mts",
+  "quality.config.js",
+  "quality.config.mjs"
+];
+var DEFAULT_BASELINE_FILE = "quality-baseline.json";
+function isJsonObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isEngineName(value) {
+  return ENGINE_NAMES.includes(value);
+}
+var ENGINE_OPTION_KEYS = {
+  biome: ["args", "ignore", "targets"],
+  typecheck: ["args", "ignore", "projects", "targets"],
+  knip: ["args", "ignore", "targets"],
+  "comment-check": ["args", "enable", "ignore", "targets"],
+  "document-style-check": ["args", "enable", "ignore", "targets"],
+  "tsdoc-check": ["args", "error", "ignore", "targets"]
+};
+function readStringArray(value, field) {
+  if (value === undefined) {
+    return;
+  }
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string" || entry === "")) {
+    throw new Error(`${field} must be an array of non-empty strings`);
+  }
+  return [...value];
+}
+function readBaseline2(value, source) {
+  if (value === undefined || value === false) {
+    return value;
+  }
+  if (typeof value === "string" && value !== "") {
+    return value;
+  }
+  throw new Error(`${source}: baseline must be a path string or false`);
+}
+function parseEngines(value, source) {
+  if (!isJsonObject2(value)) {
+    throw new Error(`${source} must export an engines object`);
+  }
+  const engines = {};
+  for (const [name, enabled] of Object.entries(value)) {
+    if (!isEngineName(name)) {
+      throw new Error(`${source}: unknown engine: ${name}`);
+    }
+    if (typeof enabled !== "boolean") {
+      throw new Error(`${source}: engines.${name} must be a boolean \u8D77\u52D5\u6761\u4EF6\u306Fconfig\u3078\u7F6E\u304F`);
+    }
+    engines[name] = enabled;
+  }
+  if (ENGINE_NAMES.every((name) => !engines[name])) {
+    throw new Error(`${source} must enable at least one engine`);
+  }
+  return engines;
+}
+function parseEngineExtras(value, source, name) {
+  const extras = {};
+  if (name === "comment-check" || name === "document-style-check") {
+    const enable = readStringArray(value.enable, `${source}: config.${name}.enable`);
+    if (enable !== undefined) {
+      extras.enable = enable;
+    }
+  }
+  if (name === "tsdoc-check") {
+    const error = readStringArray(value.error, `${source}: config.${name}.error`);
+    if (error !== undefined) {
+      extras.error = error;
+    }
+  }
+  if (name === "typecheck") {
+    const projects = readStringArray(value.projects, `${source}: config.${name}.projects`);
+    if (projects !== undefined) {
+      if (projects.length === 0) {
+        throw new Error(`${source}: config.${name}.projects must not be empty`);
+      }
+      extras.projects = projects;
+    }
+  }
+  return extras;
+}
+function parseEngineOptions(value, source, name) {
+  const unknown = Object.keys(value).filter((key) => !ENGINE_OPTION_KEYS[name].includes(key));
+  if (unknown.length > 0) {
+    throw new Error(`${source}: config.${name} has an unknown option: ${unknown[0]}`);
+  }
+  const options = {};
+  const ignore = readStringArray(value.ignore, `${source}: config.${name}.ignore`);
+  if (ignore !== undefined) {
+    options.ignore = ignore;
+  }
+  const targets = readStringArray(value.targets, `${source}: config.${name}.targets`);
+  if (targets !== undefined) {
+    options.targets = targets;
+  }
+  const args = readStringArray(value.args, `${source}: config.${name}.args`);
+  if (args !== undefined) {
+    options.args = args;
+  }
+  return { ...options, ...parseEngineExtras(value, source, name) };
+}
+function parseEngineConfig(value, source) {
+  if (value === undefined) {
+    return;
+  }
+  if (!isJsonObject2(value)) {
+    throw new Error(`${source}: config must be an object`);
+  }
+  const config = {};
+  for (const [name, options] of Object.entries(value)) {
+    if (!isEngineName(name)) {
+      throw new Error(`${source}: unknown engine in config: ${name}`);
+    }
+    if (!isJsonObject2(options)) {
+      throw new Error(`${source}: config.${name} must be an object`);
+    }
+    config[name] = parseEngineOptions(options, source, name);
+  }
+  return config;
+}
+function parseConfig(value, source) {
+  if (!isJsonObject2(value)) {
+    throw new Error(`${source} must export a config object`);
+  }
+  const config = {
+    engines: parseEngines(value.engines, source)
+  };
+  const engineConfig = parseEngineConfig(value.config, source);
+  if (engineConfig !== undefined) {
+    config.config = engineConfig;
+  }
+  const baseline = readBaseline2(value.baseline, source);
+  if (baseline !== undefined) {
+    config.baseline = baseline;
+  }
+  return config;
+}
+function enabledEngines(config) {
+  return ENGINE_NAMES.filter((name) => Boolean(config.engines[name]));
+}
+function engineConfig(config, name) {
+  if (!config.engines[name]) {
+    return null;
+  }
+  return config.config?.[name] ?? {};
+}
+function findConfigFile(cwd) {
+  for (const name of DEFAULT_CONFIG_FILES) {
+    const candidate = resolve(cwd, name);
+    if (existsSync2(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+async function loadConfig(path) {
+  const module = await import(pathToFileURL(path).href);
+  const value = isJsonObject2(module) && "default" in module ? module.default : module;
+  return parseConfig(value, path);
+}
+
+// ../shared/src/findings.ts
+function formatLocation(finding) {
+  return `${finding.file}:${finding.line}:${finding.column}`;
+}
+
+// src/engines.ts
+import { existsSync as existsSync3 } from "fs";
+import { dirname, join } from "path";
+var ENGINE_BINS = {
+  biome: "biome",
+  "comment-check": "comment-check",
+  "document-style-check": "document-style-check",
+  knip: "knip",
+  "tsdoc-check": "tsdoc-check",
+  typecheck: "tsc"
+};
+var WINDOWS_SHIMS = [".exe", ".cmd", ".bat", ""];
+var POSIX_SHIMS = [""];
+var ENGINE_LIMITS = {
+  biome: { ignore: "biome.json holds its settings" },
+  typecheck: {
+    ignore: "tsconfig.json holds its settings",
+    targets: "tsconfig.json and projects hold its settings"
+  },
+  knip: {
+    ignore: "knip.ts holds its settings",
+    targets: "knip analyzes the whole project"
+  },
+  "comment-check": {},
+  "document-style-check": {},
+  "tsdoc-check": {}
+};
+function skippedEngineOptions(name, options) {
+  if (options === undefined) {
+    return [];
+  }
+  const limits = ENGINE_LIMITS[name];
+  const skipped = [];
+  for (const key of ["ignore", "targets"]) {
+    const reason = limits[key];
+    if (reason !== undefined && options[key] !== undefined) {
+      skipped.push(`${key} skipped (${reason})`);
+    }
+  }
+  return skipped;
+}
+function isFindingEngine(name) {
+  return name === "comment-check" || name === "document-style-check" || name === "tsdoc-check";
+}
+function resolveExecutable(name, cwd) {
+  const shims = process.platform === "win32" ? WINDOWS_SHIMS : POSIX_SHIMS;
+  const bin = ENGINE_BINS[name];
+  let directory = cwd;
+  for (;; ) {
+    for (const shim of shims) {
+      const candidate = join(directory, "node_modules", ".bin", `${bin}${shim}`);
+      if (existsSync3(candidate)) {
+        return candidate;
+      }
+    }
+    const parent = dirname(directory);
+    if (parent === directory) {
+      break;
+    }
+    directory = parent;
+  }
+  const onPath = Bun.which(bin);
+  return onPath ?? null;
+}
+function colorArguments(name, color) {
+  if (!color) {
+    return [];
+  }
+  if (name === "biome") {
+    return ["--colors=force"];
+  }
+  if (name === "typecheck") {
+    return ["--pretty"];
+  }
+  return [];
+}
+function buildTypecheckCommand(executable, context, project) {
+  const options = engineConfig(context.config, "typecheck") ?? {};
+  return [
+    executable,
+    "--noEmit",
+    ...project === undefined ? [] : ["--project", project],
+    ...colorArguments("typecheck", context.color),
+    ...options.args ?? []
+  ];
+}
+function enableArguments(options) {
+  return (options?.enable ?? []).flatMap((rule) => ["--enable", rule]);
+}
+function buildEngineCommand(name, executable, context) {
+  const options = engineConfig(context.config, name) ?? {};
+  const limits = ENGINE_LIMITS[name];
+  const extra = options.args ?? [];
+  const ignores = limits.ignore === undefined ? [...options.ignore ?? [], ...context.overrides.ignore] : [];
+  const requested = context.overrides.targets.length > 0 ? context.overrides.targets : options.targets ?? ["."];
+  const targets = limits.targets === undefined ? requested : [];
+  const ignoreArguments = ignores.flatMap((ignore) => ["--ignore", ignore]);
+  const rules = engineConfig(context.config, "tsdoc-check")?.error ?? [];
+  const errorArguments = rules.flatMap((rule) => ["--error", rule]);
+  if (name === "biome") {
+    return [
+      executable,
+      "check",
+      ...colorArguments(name, context.color),
+      ...targets,
+      ...extra
+    ];
+  }
+  if (name === "typecheck") {
+    return buildTypecheckCommand(executable, context, undefined);
+  }
+  if (name === "knip") {
+    return [executable, ...extra];
+  }
+  if (name === "comment-check") {
+    return [
+      executable,
+      "--json",
+      "--baseline",
+      context.rawBaseline,
+      ...enableArguments(engineConfig(context.config, "comment-check")),
+      ...targets,
+      ...ignoreArguments,
+      ...extra
+    ];
+  }
+  if (name === "document-style-check") {
+    return [
+      executable,
+      "lint",
+      "--json",
+      ...enableArguments(engineConfig(context.config, "document-style-check")),
+      ...targets,
+      ...ignoreArguments,
+      ...extra
+    ];
+  }
+  return [
+    executable,
+    "--json",
+    ...errorArguments,
+    ...targets,
+    ...ignoreArguments,
+    ...extra
+  ];
+}
+function buildEngineCommands(name, executable, context) {
+  const projects = name === "typecheck" ? engineConfig(context.config, "typecheck")?.projects ?? [] : [];
+  if (projects.length === 0) {
+    return [buildEngineCommand(name, executable, context)];
+  }
+  return projects.map((project) => buildTypecheckCommand(executable, context, project));
+}
+async function runEngineProcess(command, options) {
+  const child = Bun.spawn({
+    cmd: command,
+    cwd: options.cwd,
+    stderr: "pipe",
+    stdout: "pipe"
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(child.stdout).text(),
+    new Response(child.stderr).text(),
+    child.exited
+  ]);
+  return { exitCode, stderr, stdout };
+}
+
+// src/report.ts
+function describeFinding(finding, paint, tone) {
+  return `${formatLocation(finding)} ${finding.rule} ${paint(finding.severity, tone)} ${finding.text}`;
+}
+function describeCounts(result) {
+  if (!isFindingEngine(result.name)) {
+    return `exit ${result.exitCode}`;
+  }
+  return `${result.reported.length} new, ${result.resolved} resolved, ${result.warnings.length} warnings`;
+}
+function describeStatus(result, paint) {
+  if (result.status === "error") {
+    return paint("error", "error");
+  }
+  const tone = result.status === "passed" ? "pass" : "error";
+  return `${paint(result.status, tone)} (${describeCounts(result)})`;
+}
+function formatEngineSection(result, paint = plainPainter) {
+  const lines = [paint(`== ${result.name} ==`, "header")];
+  for (const skipped of result.skipped) {
+    lines.push(paint(`${result.name}: ${skipped}`, "muted"));
+  }
+  if (result.output !== "" && !isFindingEngine(result.name)) {
+    lines.push(result.output);
+  }
+  for (const finding of result.reported) {
+    lines.push(describeFinding(finding, paint, "error"));
+  }
+  for (const finding of result.warnings) {
+    lines.push(describeFinding(finding, paint, "warn"));
+  }
+  if (result.message !== undefined) {
+    lines.push(paint(result.message, "error"));
+  }
+  lines.push(`${result.name}: ${describeStatus(result, paint)}`);
+  return lines.join(`
+`);
+}
+function formatSummary(results, paint = plainPainter) {
+  const failed = results.filter((result) => result.status !== "passed").map((result) => result.name);
+  const passed = results.filter((result) => result.status === "passed").map((result) => result.name);
+  if (failed.length === 0) {
+    return paint(`quality-check: ${results.length} engines passed`, "pass");
+  }
+  const lines = [
+    paint(`quality-check: ${failed.length} of ${results.length} engines failed`, "error"),
+    `  ${paint("failed:", "error")} ${failed.join(", ")}`
+  ];
+  if (passed.length > 0) {
+    lines.push(`  ${paint("passed:", "pass")} ${passed.join(", ")}`);
+  }
+  return lines.join(`
+`);
+}
+function toJsonReport(results) {
+  return {
+    engines: results.map((result) => ({
+      detected: result.detected.length,
+      exitCode: result.exitCode,
+      message: result.message ?? null,
+      name: result.name,
+      reported: result.reported,
+      resolved: result.resolved,
+      skipped: result.skipped,
+      status: result.status,
+      warnings: result.warnings
+    })),
+    failed: results.filter((result) => result.status !== "passed").map((result) => result.name)
+  };
+}
+
+// src/findings.ts
+function readFinding(engine, value, severity, textField) {
+  if (!isJsonObject(value)) {
+    throw new Error(`${engine} printed an unexpected finding`);
+  }
+  const { column, file, line, rule } = value;
+  const text = value[textField];
+  if (typeof rule !== "string" || typeof file !== "string" || typeof line !== "number" || typeof column !== "number" || typeof text !== "string") {
+    throw new Error(`${engine} printed an unexpected finding`);
+  }
+  return { column, engine, file, line, rule, severity, text };
+}
+function readEntries(engine, value, field) {
+  if (!Array.isArray(value)) {
+    throw new Error(`${engine} printed JSON without a ${field} array`);
+  }
+  return value;
+}
+function parseJson(engine, stdout) {
+  let value;
+  try {
+    value = JSON.parse(stdout);
+  } catch {
+    throw new Error(`${engine} did not print JSON`);
+  }
+  if (!isJsonObject(value)) {
+    throw new Error(`${engine} printed an unexpected JSON value`);
+  }
+  return value;
+}
+function parseFindings(engine, stdout) {
+  const value = parseJson(engine, stdout);
+  if (engine === "comment-check") {
+    return {
+      errors: readEntries(engine, value.added, "added").map((entry) => readFinding(engine, entry, "error", "text")),
+      warnings: []
+    };
+  }
+  return {
+    errors: readEntries(engine, value.errors, "errors").map((entry) => readFinding(engine, entry, "error", "message")),
+    warnings: readEntries(engine, value.warnings, "warnings").map((entry) => readFinding(engine, entry, "warning", "message"))
+  };
+}
+
+// src/run.ts
+function baseResult(name, exitCode, output) {
+  return {
+    detected: [],
+    exitCode,
+    name,
+    output,
+    reported: [],
+    resolved: 0,
+    skipped: [],
+    warnings: []
+  };
+}
+function joinOutput(result) {
+  return [result.stdout, result.stderr].map((part) => part.trimEnd()).filter((part) => part !== "").join(`
+`);
+}
+function describeError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function combineExitCode(codes) {
+  if (codes.some((code) => code === 2)) {
+    return 2;
+  }
+  const failed = codes.find((code) => code !== 0);
+  return failed === undefined ? 0 : failed;
+}
+async function runCommands(commands, options, runner) {
+  const executed = [];
+  for (const command of commands) {
+    executed.push({ command, result: await runner(command, options) });
+  }
+  const labeled = commands.length > 1;
+  const output = executed.map(({ command, result }) => {
+    const text = joinOutput(result);
+    if (!labeled) {
+      return text;
+    }
+    const header = `$ ${command.join(" ")}`;
+    return text === "" ? header : `${header}
+${text}`;
+  }).filter((block) => block !== "").join(`
+
+`);
+  const exitCode = combineExitCode(executed.map((entry) => entry.result.exitCode));
+  return { exitCode, output };
+}
+async function runFindingEngine(name, options, executable, context, runner) {
+  const result = await runner(buildEngineCommand(name, executable, context), {
+    cwd: options.cwd
+  });
+  const output = joinOutput(result);
+  if (result.exitCode === 2) {
+    return {
+      ...baseResult(name, 2, output),
+      message: `${name} could not finish`,
+      status: "error"
+    };
+  }
+  let parsed;
+  try {
+    parsed = parseFindings(name, result.stdout);
+  } catch (error) {
+    return {
+      ...baseResult(name, result.exitCode, output),
+      message: describeError(error),
+      status: "error"
+    };
+  }
+  const comparison = options.baseline === null ? { added: parsed.errors, resolved: [] } : compareWithBaseline(parsed.errors, options.baseline);
+  return {
+    ...baseResult(name, result.exitCode, output),
+    detected: parsed.errors,
+    reported: comparison.added,
+    resolved: comparison.resolved.length,
+    status: comparison.added.length > 0 ? "failed" : "passed",
+    warnings: parsed.warnings
+  };
+}
+async function runProcessEngine(name, options, executable, context, runner) {
+  const commands = buildEngineCommands(name, executable, context);
+  const { exitCode, output } = await runCommands(commands, { cwd: options.cwd }, runner);
+  if (exitCode === 2) {
+    return {
+      ...baseResult(name, 2, output),
+      message: `${name} could not finish`,
+      status: "error"
+    };
+  }
+  return {
+    ...baseResult(name, exitCode, output),
+    status: exitCode === 0 ? "passed" : "failed"
+  };
+}
+async function executeEngine(name, options, context, runner) {
+  const executable = (options.resolve ?? resolveExecutable)(name, options.cwd);
+  if (executable === null) {
+    return {
+      ...baseResult(name, null, ""),
+      message: `${ENGINE_BINS[name]} is not installed`,
+      status: "error"
+    };
+  }
+  if (isFindingEngine(name)) {
+    return await runFindingEngine(name, options, executable, context, runner);
+  }
+  return await runProcessEngine(name, options, executable, context, runner);
+}
+async function runEngine(name, options, context, runner) {
+  const result = await executeEngine(name, options, context, runner);
+  return {
+    ...result,
+    skipped: skippedEngineOptions(name, options.config.config?.[name])
+  };
+}
+async function runEngines(options) {
+  const runner = options.runner ?? runEngineProcess;
+  const context = {
+    color: options.color,
+    config: options.config,
+    overrides: options.overrides,
+    rawBaseline: options.rawBaseline
+  };
+  const results = [];
+  for (const name of enabledEngines(options.config)) {
+    results.push(await runEngine(name, options, context, runner));
+  }
+  return results;
+}
+
+// src/cli.ts
+var USAGE = "Usage: quality-check [--config <path>] [--baseline <path>] [--ignore <path>] [--update-baseline] [--json] [path...]";
+function parseArguments(argv) {
+  const parsed = parseArgv(argv, {
+    flags: ["json", "update-baseline"],
+    values: ["baseline", "config", "ignore"]
+  });
+  return {
+    baselinePath: parsed.values.get("baseline")?.at(-1),
+    configPath: parsed.values.get("config")?.at(-1),
+    ignores: [...parsed.values.get("ignore") ?? []],
+    json: parsed.flags.has("json"),
+    targets: parsed.targets,
+    update: parsed.flags.has("update-baseline")
+  };
+}
+function resolveBaselinePath(options, config, cwd) {
+  if (options.baselinePath !== undefined) {
+    return resolve2(cwd, options.baselinePath);
+  }
+  if (config.baseline === false) {
+    return null;
+  }
+  return resolve2(cwd, config.baseline ?? DEFAULT_BASELINE_FILE);
+}
+function resolveConfigPath(options, cwd) {
+  if (options.configPath !== undefined) {
+    return resolve2(cwd, options.configPath);
+  }
+  return findConfigFile(cwd);
+}
+async function main(argv) {
+  if (wantsHelp(argv)) {
+    console.log(USAGE);
+    return 0;
+  }
+  const options = parseArguments(argv);
+  const color = colorEnabled(process.stdout, process.env);
+  const paint = color ? ansiPainter() : plainPainter;
+  const cwd = process.cwd();
+  const configPath = resolveConfigPath(options, cwd);
+  if (configPath === null) {
+    console.error(`quality.config.ts not found in ${cwd}`);
+    return 2;
+  }
+  const config = await loadConfig(configPath);
+  const baselinePath = resolveBaselinePath(options, config, cwd);
+  const results = await runEngines({
+    baseline: options.update || baselinePath === null ? null : readBaseline(baselinePath, "quality"),
+    color,
+    config,
+    cwd,
+    overrides: { ignore: options.ignores, targets: options.targets },
+    rawBaseline: join2(tmpdir(), `quality-check-raw-${process.pid}.json`)
+  });
+  if (options.update) {
+    if (baselinePath === null) {
+      console.error("baseline is disabled by the configuration");
+      return 2;
+    }
+    const baseline = createBaseline(results.flatMap((result) => result.detected));
+    writeBaseline(baselinePath, baseline);
+    console.log(paint(`Recorded ${baseline.entries.length} entries in ${baselinePath}`, "pass"));
+    return 0;
+  }
+  if (options.json) {
+    console.log(JSON.stringify(toJsonReport(results), null, "\t"));
+  } else {
+    for (const result of results) {
+      console.log(formatEngineSection(result, paint));
+    }
+    console.log(formatSummary(results, paint));
+  }
+  return results.some((result) => result.status !== "passed") ? 1 : 0;
+}
+runCli(main);