@iowarp/clio-coder 0.4.9 → 0.5.0

package/dist/verifiers-ECA5GIHL.js

@@ -0,0 +1,633 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  createVerifierDraft,
+  discoverVerifierAuthoring,
+  previewVerifierDraft,
+  runVerifierAuthoringWorkflow
+} from "./chunk-6RJMYYIE.js";
+import {
+  verifyTool
+} from "./chunk-4SYHGVDE.js";
+import "./chunk-LQTKDAUO.js";
+import "./chunk-ZU4JPCPR.js";
+import {
+  recordPerfBaseline
+} from "./chunk-7RET77VB.js";
+import {
+  printError,
+  printOk
+} from "./chunk-NBXFPI7U.js";
+import "./chunk-SQZHXUB3.js";
+import "./chunk-YBUECLAF.js";
+import "./chunk-CRHPCPZP.js";
+import "./chunk-DZLR4UEH.js";
+import {
+  DECLARED_CHECK_KINDS,
+  PROJECT_VERIFIER_CATALOG_RELATIVE_PATH,
+  loadProjectVerifierCatalog
+} from "./chunk-6CTHLZFB.js";
+import {
+  normalizeNumericTolerance
+} from "./chunk-2KUBKL63.js";
+import "./chunk-MYI32N4R.js";
+import "./chunk-VNBICSS2.js";
+import "./chunk-L7G7K4I2.js";
+import "./chunk-ALJWT6O6.js";
+import "./chunk-C2CPOIH2.js";
+import "./chunk-MGLRTOCK.js";
+import {
+  isProjectVerifierCheckId
+} from "./chunk-M4KFUXS7.js";
+import "./chunk-V4XJWDHR.js";
+import "./chunk-B5GGDIHT.js";
+import {
+  SAFE_EXEC_DEFAULT_TIMEOUT_MS
+} from "./chunk-M2IPMWCN.js";
+import "./chunk-XS2QPZJE.js";
+import "./chunk-6EXUUOSN.js";
+import "./chunk-ZTNFYMIO.js";
+import "./chunk-GH5ZR6JP.js";
+import "./chunk-CTTI7G3T.js";
+import "./chunk-FD2I4KBR.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/cli/verifiers.ts
+init_esm_shims();
+
+// src/cli/verifiers-inspect.ts
+init_esm_shims();
+var MAX_VERIFIERS_INSPECT_CHECKS = 64;
+var TAG_PATTERN = /^[a-z0-9][a-z0-9._-]*$/;
+var REJECTION_LOCATION_PATTERN = /^(root|checks\[\d{1,3}\])(\.[a-zA-Z]{1,32}(\[\d{1,3}\])?)?$/;
+var VERIFIER_RUNNERS = [
+  "npm",
+  "pnpm",
+  "yarn",
+  "bun",
+  "deno",
+  "node",
+  "cargo",
+  "go",
+  "make",
+  "just",
+  "cmake",
+  "ctest",
+  "ninja",
+  "python",
+  "pytest",
+  "uv",
+  "tox",
+  "nox",
+  "dotnet",
+  "gradle",
+  "maven",
+  "rake",
+  "swift",
+  "other"
+];
+var RUNNER_ALIASES = /* @__PURE__ */ new Map([
+  ["python3", "python"],
+  ["python2", "python"],
+  ["py", "python"],
+  ["mvn", "maven"],
+  ["gradlew", "gradle"],
+  ["mvnw", "maven"],
+  ["npx", "npm"],
+  ["pnpx", "pnpm"],
+  ["go-test", "go"]
+]);
+function hasControlCharacter(value) {
+  for (const character of value) {
+    const code = character.codePointAt(0) ?? 0;
+    if (code <= 31 || code === 127) return true;
+  }
+  return false;
+}
+function runnerOf(executable) {
+  if (executable === void 0) return "other";
+  const separator = Math.max(executable.lastIndexOf("/"), executable.lastIndexOf("\\"));
+  const base = executable.slice(separator + 1).toLowerCase().replace(/\.(exe|cmd|bat|ps1)$/u, "");
+  const alias = RUNNER_ALIASES.get(base);
+  if (alias !== void 0) return alias;
+  return VERIFIER_RUNNERS.includes(base) ? base : "other";
+}
+function rejectionMessage(reason) {
+  const prefix = `${PROJECT_VERIFIER_CATALOG_RELATIVE_PATH}: `;
+  return reason.startsWith(prefix) ? reason.slice(prefix.length) : reason;
+}
+function rejectionLocation(message) {
+  const match = /^(?:root|checks\[\d{1,3}\])(?:\.[a-zA-Z]{1,32}(?:\[\d{1,3}\])?)?/u.exec(message);
+  const candidate = match?.[0];
+  if (candidate === void 0) return null;
+  return REJECTION_LOCATION_PATTERN.test(candidate) ? candidate : null;
+}
+function classifyRejection(reason) {
+  const message = rejectionMessage(reason);
+  const rejectedAt = rejectionLocation(message);
+  const has = (fragment) => message.includes(fragment);
+  const rejection = has("invalid YAML") ? "invalid-yaml" : has("cannot read catalog") || has("must be a regular file") || has("must resolve inside the workspace root") ? "unreadable" : has("unsupported version") ? "unsupported-version" : has("has unknown field(s)") ? "unknown-field" : has(" is required") ? "missing-field" : has("duplicates '") || has("contains duplicate tag") ? "duplicate-id" : has("may not invoke shell executable") || has("must be one executable token") || has("shell command strings are not allowed") ? "shell-command" : has("exceeds the") ? "too-large" : rejectedAt?.endsWith(".cwd") === true ? "invalid-cwd" : has("must be") || has("must match") || has("must not contain") || has("uses reserved") ? "invalid-value" : "unclassified";
+  return { rejection, rejectedAt };
+}
+function classifyBlock(reason) {
+  if (reason.includes(`${PROJECT_VERIFIER_CATALOG_RELATIVE_PATH}: `)) return "catalog-rejected";
+  if (reason.includes("duplicate declared check id ")) return "id-collision";
+  return "unclassified";
+}
+function projectCheck(check) {
+  if (check.state === "manual") return null;
+  if (!isProjectVerifierCheckId(check.id) || check.id.length > 64) return null;
+  if (check.description.trim() !== check.description || check.description.length === 0) return null;
+  if (hasControlCharacter(check.description) || check.description.length > 512) return null;
+  const tags2 = check.tags.filter((tag) => TAG_PATTERN.test(tag) && tag.length <= 32);
+  if (tags2.length !== check.tags.length) return null;
+  const origin = check.state === "active" ? "package-script" : check.state === "existing" ? "catalog" : "proposed";
+  return {
+    id: check.id,
+    description: check.description,
+    origin,
+    signal: check.provenance.kind,
+    authority: check.provenance.authority,
+    runner: runnerOf(check.command[0]),
+    argumentCount: Math.max(check.command.length - 1, 0),
+    runsAtRepositoryRoot: check.cwd === ".",
+    argvFixed: origin !== "package-script",
+    timeoutMs: check.timeoutMs,
+    tags: tags2
+  };
+}
+var ORIGIN_RANK = { "package-script": 0, catalog: 1, proposed: 2 };
+function verifiersInspectSnapshot(now = Date.now, workspaceRoot = process.cwd()) {
+  const generatedAt = new Date(now()).toISOString();
+  const catalog = loadProjectVerifierCatalog(workspaceRoot);
+  const catalogPresent = catalog.ok ? catalog.source !== null : true;
+  const classified = catalog.ok ? null : classifyRejection(catalog.reason);
+  const discovery = discoverVerifierAuthoring(workspaceRoot);
+  const base = {
+    version: 1,
+    generatedAt,
+    catalogPresent,
+    catalogValid: catalog.ok ? catalog.source === null ? null : true : false,
+    rejection: classified?.rejection ?? null,
+    rejectedAt: classified?.rejectedAt ?? null
+  };
+  if (!discovery.ok) {
+    return {
+      ...base,
+      discovery: "blocked",
+      blockedBy: classifyBlock(discovery.reason),
+      checks: [],
+      checksTruncated: false,
+      diagnosticCount: 0
+    };
+  }
+  const projected = [...discovery.activeChecks, ...discovery.existingChecks, ...discovery.proposals].map(projectCheck).filter((check) => check !== null).sort(
+    (left, right) => ORIGIN_RANK[left.origin] !== ORIGIN_RANK[right.origin] ? ORIGIN_RANK[left.origin] - ORIGIN_RANK[right.origin] : left.id < right.id ? -1 : left.id > right.id ? 1 : 0
+  );
+  const checks = projected.slice(0, MAX_VERIFIERS_INSPECT_CHECKS);
+  return {
+    ...base,
+    discovery: "complete",
+    blockedBy: null,
+    checks,
+    checksTruncated: checks.length < projected.length,
+    diagnosticCount: discovery.diagnostics.length
+  };
+}
+function runVerifiersInspect(args) {
+  if (args.length !== 1 || args[0] !== "--json") {
+    process.stderr.write("clio-coder verifiers inspect: usage: clio-coder verifiers inspect --json\n");
+    return 2;
+  }
+  process.stdout.write(`${JSON.stringify(verifiersInspectSnapshot(), null, 2)}
+`);
+  return 0;
+}
+
+// src/cli/verifiers.ts
+var HELP = `Project verifier authoring
+
+Usage:
+  clio-coder verifiers discover
+  clio-coder verifiers inspect --json
+  clio-coder verifiers author [--exclude <id>] [--rename <old>=<new>] [--dry-run <id>] [--yes]
+  clio-coder verifiers validate
+  clio-coder verifiers dry-run <id>
+  clio-coder verifiers add --id <id> --description <text> --command <json-argv> [fields] [--yes]
+  clio-coder verifiers edit <id> [--description <text>] [--command <json-argv>] [fields] [--yes]
+  clio-coder verifiers rename <old> <new> [--yes]
+  clio-coder verifiers remove <id> [--yes]
+  clio-coder verifiers baseline <id>
+
+Fields:
+  --cwd <path>            repository-relative working directory (default .)
+  --timeout-ms <number>   bounded timeout in milliseconds (default 120000)
+  --tags <a,b>            comma-separated catalog tags
+  --kind <kind>           command (default), numeric-compare, or perf-budget
+  --reference <path>      numeric-compare: repository-relative reference JSON of string -> number | number[]
+  --tolerance <json>      numeric-compare: {"relative"?,"absolute"?,"ulp"?,"combine"?:all|any,"nonFinite"?:fail|match}, at least one numeric bound;
+                          perf-budget with --baseline: {"relative"} headroom over the baseline
+  --budget-ms <number>    perf-budget: wall-time bound in milliseconds
+  --budget-relative <r>   perf-budget with --budget-ms: fractional headroom over the bound
+  --baseline <path>       perf-budget: repository-relative baseline JSON written by 'verifiers baseline <id>'
+
+baseline runs a perf-budget check once and records its wall time at the check's
+baseline path; a failing or timed-out command records nothing.
+
+Discovery and every preview are read-only. Mutating commands write only with
+--yes after printing the exact argv, cwd, timeout, tags, source provenance, and
+effective execution authority. dry-run invokes the production verify path.
+
+inspect is the fixed machine-readable read a GUI host may run. It takes no other
+argument, runs no check, and carries no argv, cwd, source path, or diagnostic
+text: the toolchain each check drives is classified, and the arguments stay here.
+`;
+var VALUE_OPTIONS = /* @__PURE__ */ new Set([
+  "--id",
+  "--description",
+  "--command",
+  "--cwd",
+  "--timeout-ms",
+  "--tags",
+  "--exclude",
+  "--rename",
+  "--dry-run",
+  "--kind",
+  "--reference",
+  "--tolerance",
+  "--budget-ms",
+  "--budget-relative",
+  "--baseline"
+]);
+function parseAuthoringArgs(argv) {
+  const positional = [];
+  const values = /* @__PURE__ */ new Map();
+  let yes = false;
+  let help = false;
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--yes") {
+      yes = true;
+      continue;
+    }
+    if (arg === "--help" || arg === "-h") {
+      help = true;
+      continue;
+    }
+    if (arg?.startsWith("--") === true) {
+      if (!VALUE_OPTIONS.has(arg)) return { yes, help, positional, values, error: `unknown option: ${arg}` };
+      const value = argv[index + 1];
+      if (value === void 0 || value.startsWith("--")) {
+        return { yes, help, positional, values, error: `${arg} requires a value` };
+      }
+      const prior = values.get(arg) ?? [];
+      prior.push(value);
+      values.set(arg, prior);
+      index += 1;
+      continue;
+    }
+    if (arg !== void 0) positional.push(arg);
+  }
+  return { yes, help, positional, values };
+}
+function oneValue(parsed, option) {
+  return parsed.values.get(option)?.at(-1);
+}
+function parseCommand(value) {
+  if (value === void 0) return new Error("--command is required and must be a JSON argv array");
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch (error) {
+    return new Error(`--command must be valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!Array.isArray(parsed) || parsed.length === 0 || parsed.some((entry) => typeof entry !== "string")) {
+    return new Error("--command must be a non-empty JSON string array");
+  }
+  return parsed;
+}
+function parseTimeout(value) {
+  if (value === void 0) return SAFE_EXEC_DEFAULT_TIMEOUT_MS;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed <= 0) return new Error("--timeout-ms must be a positive integer");
+  return parsed;
+}
+function tags(value) {
+  return value === void 0 ? [] : value.split(",").map((tag) => tag.trim()).filter((tag) => tag.length > 0);
+}
+function parseJsonObject(value, option) {
+  try {
+    const parsed = JSON.parse(value);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return new Error(`${option} must be a JSON object`);
+    }
+    return parsed;
+  } catch (error) {
+    return new Error(`${option} must be valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function kindFieldsFromArgs(parsed) {
+  const kindValue = oneValue(parsed, "--kind") ?? "command";
+  if (!DECLARED_CHECK_KINDS.includes(kindValue)) {
+    return new Error(`--kind must be one of ${DECLARED_CHECK_KINDS.join(", ")}`);
+  }
+  const kind = kindValue;
+  const reference = oneValue(parsed, "--reference");
+  const toleranceValue = oneValue(parsed, "--tolerance");
+  const budgetMs = oneValue(parsed, "--budget-ms");
+  const budgetRelative = oneValue(parsed, "--budget-relative");
+  const baseline = oneValue(parsed, "--baseline");
+  if (kind === "command") {
+    const stray = [
+      ["--reference", reference],
+      ["--tolerance", toleranceValue],
+      ["--budget-ms", budgetMs],
+      ["--budget-relative", budgetRelative],
+      ["--baseline", baseline]
+    ].filter(([, value]) => value !== void 0);
+    if (stray.length > 0)
+      return new Error(`${stray.map(([name]) => name).join(", ")} require --kind numeric-compare or perf-budget`);
+    return {};
+  }
+  if (kind === "numeric-compare") {
+    if (budgetMs !== void 0 || budgetRelative !== void 0 || baseline !== void 0) {
+      return new Error("--budget-ms, --budget-relative, and --baseline belong to --kind perf-budget");
+    }
+    if (reference === void 0) return new Error("--reference is required for --kind numeric-compare");
+    if (toleranceValue === void 0) return new Error("--tolerance is required for --kind numeric-compare");
+    const toleranceJson = parseJsonObject(toleranceValue, "--tolerance");
+    if (toleranceJson instanceof Error) return toleranceJson;
+    const tolerance = normalizeNumericTolerance(toleranceJson);
+    if (tolerance instanceof Error) return new Error(`--tolerance ${tolerance.message}`);
+    return { kind, numeric: { reference, tolerance } };
+  }
+  if (reference !== void 0) return new Error("--reference belongs to --kind numeric-compare");
+  if (budgetMs === void 0 === (baseline === void 0)) {
+    return new Error("--kind perf-budget requires exactly one of --budget-ms or --baseline");
+  }
+  if (budgetMs !== void 0) {
+    if (toleranceValue !== void 0) return new Error("use --budget-relative for headroom over --budget-ms");
+    const wallTimeMs = Number(budgetMs);
+    if (!Number.isFinite(wallTimeMs) || wallTimeMs <= 0) return new Error("--budget-ms must be a positive number");
+    const budget = { wallTimeMs };
+    if (budgetRelative !== void 0) {
+      const relative = Number(budgetRelative);
+      if (!Number.isFinite(relative) || relative < 0) return new Error("--budget-relative must be a non-negative number");
+      budget.tolerance = { relative };
+    }
+    return { kind, perf: { budget } };
+  }
+  if (budgetRelative !== void 0)
+    return new Error("--budget-relative belongs with --budget-ms; use --tolerance with --baseline");
+  const perf = { baseline };
+  if (toleranceValue !== void 0) {
+    const toleranceJson = parseJsonObject(toleranceValue, "--tolerance");
+    if (toleranceJson instanceof Error) return toleranceJson;
+    const relative = toleranceJson.relative;
+    if (typeof relative !== "number" || !Number.isFinite(relative) || relative < 0) {
+      return new Error('--tolerance for a baseline must be {"relative": <non-negative number>}');
+    }
+    perf.tolerance = { relative };
+  }
+  return { kind, perf };
+}
+function requiredValue(parsed, option) {
+  const value = oneValue(parsed, option);
+  return value === void 0 || value.length === 0 ? new Error(`${option} is required`) : value;
+}
+function authorRevisions(parsed) {
+  const revisions = [];
+  for (const id of parsed.values.get("--exclude") ?? []) revisions.push({ kind: "remove", id });
+  for (const rename of parsed.values.get("--rename") ?? []) {
+    const separator = rename.indexOf("=");
+    if (separator <= 0 || separator === rename.length - 1) {
+      return new Error("--rename must use <old>=<new>");
+    }
+    revisions.push({ kind: "rename", id: rename.slice(0, separator), newId: rename.slice(separator + 1) });
+  }
+  return revisions;
+}
+function addRevision(parsed) {
+  const id = requiredValue(parsed, "--id");
+  if (id instanceof Error) return id;
+  const description = requiredValue(parsed, "--description");
+  if (description instanceof Error) return description;
+  const command = parseCommand(oneValue(parsed, "--command"));
+  if (command instanceof Error) return command;
+  const timeoutMs = parseTimeout(oneValue(parsed, "--timeout-ms"));
+  if (timeoutMs instanceof Error) return timeoutMs;
+  const kindFields = kindFieldsFromArgs(parsed);
+  if (kindFields instanceof Error) return kindFields;
+  return {
+    kind: "add",
+    check: {
+      id,
+      description,
+      command,
+      cwd: oneValue(parsed, "--cwd") ?? ".",
+      timeoutMs,
+      tags: tags(oneValue(parsed, "--tags")),
+      ...kindFields
+    }
+  };
+}
+function editRevision(parsed) {
+  const id = parsed.positional[1];
+  if (id === void 0) return new Error("edit requires a check ID");
+  const changes = {};
+  const description = oneValue(parsed, "--description");
+  if (description !== void 0) changes.description = description;
+  const commandValue = oneValue(parsed, "--command");
+  if (commandValue !== void 0) {
+    const command = parseCommand(commandValue);
+    if (command instanceof Error) return command;
+    changes.command = command;
+  }
+  const cwd = oneValue(parsed, "--cwd");
+  if (cwd !== void 0) changes.cwd = cwd;
+  const timeoutValue = oneValue(parsed, "--timeout-ms");
+  if (timeoutValue !== void 0) {
+    const timeoutMs = parseTimeout(timeoutValue);
+    if (timeoutMs instanceof Error) return timeoutMs;
+    changes.timeoutMs = timeoutMs;
+  }
+  const tagValue = oneValue(parsed, "--tags");
+  if (tagValue !== void 0) changes.tags = tags(tagValue);
+  if (oneValue(parsed, "--kind") !== void 0) {
+    const kindFields = kindFieldsFromArgs(parsed);
+    if (kindFields instanceof Error) return kindFields;
+    changes.kind = kindFields.kind ?? "command";
+    if (kindFields.numeric !== void 0) changes.numeric = kindFields.numeric;
+    if (kindFields.perf !== void 0) changes.perf = kindFields.perf;
+  }
+  if (Object.keys(changes).length === 0) return new Error("edit requires at least one changed field");
+  return { kind: "edit", id, changes };
+}
+function mutationRevision(parsed) {
+  const command = parsed.positional[0];
+  if (command === "add") return addRevision(parsed);
+  if (command === "edit") return editRevision(parsed);
+  if (command === "rename") {
+    const id = parsed.positional[1];
+    const newId = parsed.positional[2];
+    if (id === void 0 || newId === void 0) return new Error("rename requires <old> and <new> IDs");
+    return { kind: "rename", id, newId };
+  }
+  if (command === "remove") {
+    const id = parsed.positional[1];
+    if (id === void 0) return new Error("remove requires a check ID");
+    return { kind: "remove", id };
+  }
+  return new Error(`unknown verifiers command: ${command ?? "(none)"}`);
+}
+function printDryRun(id, result) {
+  if (result.kind === "error") {
+    printError(`dry-run '${id}' failed: ${result.message}`);
+    return 1;
+  }
+  process.stdout.write(`Dry run '${id}':
+${result.output}${result.output.endsWith("\n") ? "" : "\n"}`);
+  return 0;
+}
+async function executeWorkflow(parsed, options) {
+  let printedPreview = false;
+  const dryRunCheckIds = parsed.values.get("--dry-run") ?? [];
+  const result = await runVerifierAuthoringWorkflow({
+    includeProposals: options.includeProposals,
+    initialRevisions: options.revisions,
+    confirmed: parsed.yes,
+    decide(context) {
+      process.stdout.write(`${context.preview}
+`);
+      printedPreview = true;
+      if (!parsed.yes || context.draft.checks.length === 0 && options.revisions.length === 0) {
+        return { kind: "reject" };
+      }
+      return { kind: "confirm", dryRunCheckIds };
+    }
+  });
+  if (result.status === "invalid") {
+    if (!printedPreview && result.preview !== void 0) process.stdout.write(`${result.preview}
+`);
+    printError(result.reason);
+    if (result.wrote && result.path !== void 0) {
+      process.stderr.write(`  ${result.path} was written; repair or remove it before running a check.
+`);
+    }
+    return 1;
+  }
+  if (result.status === "rejected") {
+    if (!parsed.yes) {
+      process.stdout.write("Review complete. Nothing changed; rerun the same command with --yes to write this preview.\n");
+    } else {
+      process.stdout.write(
+        "Nothing changed because the preview contains no catalog checks. Package checks remain active; unsupported commands can be added with `clio-coder verifiers add`.\n"
+      );
+    }
+    return 0;
+  }
+  printOk(`wrote ${result.path}; production parser accepted the catalog`);
+  let code = 0;
+  for (const dryRun of result.dryRuns) code = Math.max(code, printDryRun(dryRun.id, dryRun.result));
+  return code;
+}
+async function baselineCommand(id) {
+  if (id === void 0) {
+    printError("baseline requires a check ID");
+    return 2;
+  }
+  const loaded = loadProjectVerifierCatalog(process.cwd());
+  if (!loaded.ok) {
+    printError(`production catalog parser rejected ${loaded.reason}`);
+    return 1;
+  }
+  const check = loaded.source?.checks.find((candidate) => candidate.id === id);
+  if (check === void 0) {
+    printError(`no catalog check '${id}' in ${PROJECT_VERIFIER_CATALOG_RELATIVE_PATH}`);
+    return 1;
+  }
+  const recorded = await recordPerfBaseline(check);
+  if (!recorded.ok) {
+    printError(`baseline '${id}' not recorded: ${recorded.message}`);
+    return 1;
+  }
+  printOk(`recorded baseline for '${id}': ${Math.round(recorded.wallTimeMs)}ms at ${recorded.path}`);
+  return 0;
+}
+async function discoverCommand() {
+  const discovery = discoverVerifierAuthoring();
+  if (!discovery.ok) {
+    printError(discovery.reason);
+    process.stderr.write(`${discovery.manualEntry}
+`);
+    return 1;
+  }
+  process.stdout.write(`${previewVerifierDraft(createVerifierDraft(discovery))}
+`);
+  return 0;
+}
+function validateCommand() {
+  const loaded = loadProjectVerifierCatalog(process.cwd());
+  if (!loaded.ok) {
+    printError(`production catalog parser rejected ${loaded.reason}`);
+    return 1;
+  }
+  if (loaded.source === null) {
+    process.stdout.write(`No ${PROJECT_VERIFIER_CATALOG_RELATIVE_PATH} exists. Run \`clio-coder verifiers author\`.
+`);
+    return 0;
+  }
+  printOk(
+    `production catalog parser accepted ${PROJECT_VERIFIER_CATALOG_RELATIVE_PATH} (${loaded.source.checks.length} check${loaded.source.checks.length === 1 ? "" : "s"})`
+  );
+  return 0;
+}
+async function runVerifiersCommand(argv) {
+  if (argv[0] === "inspect") return runVerifiersInspect(argv.slice(1));
+  const parsed = parseAuthoringArgs(argv);
+  if (parsed.error !== void 0) {
+    printError(parsed.error);
+    process.stderr.write(HELP);
+    return 2;
+  }
+  if (parsed.help || parsed.positional.length === 0) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  const command = parsed.positional[0];
+  if (command === "discover") return discoverCommand();
+  if (command === "validate") return validateCommand();
+  if (command === "baseline") return baselineCommand(parsed.positional[1]);
+  if (command === "dry-run") {
+    const id = parsed.positional[1];
+    if (id === void 0) {
+      printError("dry-run requires a check ID");
+      return 2;
+    }
+    return printDryRun(id, await verifyTool.run({ check: id }));
+  }
+  if (command === "author") {
+    const revisions = authorRevisions(parsed);
+    if (revisions instanceof Error) {
+      printError(revisions.message);
+      return 2;
+    }
+    return executeWorkflow(parsed, { includeProposals: true, revisions });
+  }
+  if (["add", "edit", "rename", "remove"].includes(command ?? "")) {
+    const revision = mutationRevision(parsed);
+    if (revision instanceof Error) {
+      printError(revision.message);
+      return 2;
+    }
+    return executeWorkflow(parsed, { includeProposals: false, revisions: [revision] });
+  }
+  printError(`unknown verifiers command: ${command}`);
+  process.stderr.write(HELP);
+  return 2;
+}
+export {
+  runVerifiersCommand
+};
+//# sourceMappingURL=verifiers-ECA5GIHL.js.map

package/dist/verify-R6QQCCEB.js

@@ -0,0 +1,31 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  verifyTool
+} from "./chunk-4SYHGVDE.js";
+import "./chunk-7RET77VB.js";
+import "./chunk-YBUECLAF.js";
+import "./chunk-CRHPCPZP.js";
+import "./chunk-DZLR4UEH.js";
+import "./chunk-6CTHLZFB.js";
+import "./chunk-2KUBKL63.js";
+import "./chunk-MYI32N4R.js";
+import "./chunk-VNBICSS2.js";
+import "./chunk-L7G7K4I2.js";
+import "./chunk-ALJWT6O6.js";
+import "./chunk-C2CPOIH2.js";
+import "./chunk-MGLRTOCK.js";
+import "./chunk-M4KFUXS7.js";
+import "./chunk-V4XJWDHR.js";
+import "./chunk-B5GGDIHT.js";
+import "./chunk-M2IPMWCN.js";
+import "./chunk-XS2QPZJE.js";
+import "./chunk-6EXUUOSN.js";
+import "./chunk-ZTNFYMIO.js";
+import "./chunk-GH5ZR6JP.js";
+import "./chunk-CTTI7G3T.js";
+import "./chunk-FD2I4KBR.js";
+import "./chunk-ECBHH7LU.js";
+export {
+  verifyTool
+};
+//# sourceMappingURL=verify-R6QQCCEB.js.map

package/dist/version-PLZYB5KW.js

@@ -0,0 +1,22 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  getVersionInfo
+} from "./chunk-2VLYHHFT.js";
+import "./chunk-3JHUFKG7.js";
+import "./chunk-ZPST2KQO.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/cli/version.ts
+init_esm_shims();
+function runVersionCommand() {
+  const v = getVersionInfo();
+  process.stdout.write(`Clio Coder ${v.clio}
+`);
+  return 0;
+}
+export {
+  runVersionCommand
+};
+//# sourceMappingURL=version-PLZYB5KW.js.map