readyup 0.0.0 → 0.13.0

package/dist/esm/cli.js

@@ -0,0 +1,285 @@
+import path from "node:path";
+import process from "node:process";
+import { loadRdyKit } from "./config.js";
+import { formatCombinedSummary } from "./formatCombinedSummary.js";
+import { formatJsonError } from "./formatJsonError.js";
+import { formatJsonReport } from "./formatJsonReport.js";
+import { loadRemoteKit } from "./loadRemoteKit.js";
+import { parseArgs } from "./parseArgs.js";
+import { reportRdy } from "./reportRdy.js";
+import { resolveGitHubToken } from "./resolveGitHubToken.js";
+import { resolveRequestedNames } from "./resolveRequestedNames.js";
+import { meetsThreshold, runRdy } from "./runRdy.js";
+const VALID_SEVERITIES = /* @__PURE__ */ new Set(["error", "warn", "recommend"]);
+const runFlagSchema = {
+  file: { long: "--file", type: "string", short: "-f" },
+  github: { long: "--github", type: "string", short: "-g" },
+  url: { long: "--url", type: "string", short: "-u" },
+  kit: { long: "--kit", type: "string", short: "-k" },
+  local: { long: "--local", type: "string", short: "-l" },
+  json: { long: "--json", type: "boolean", short: "-j" },
+  failOn: { long: "--fail-on", type: "string", short: "-F" },
+  reportOn: { long: "--report-on", type: "string", short: "-R" }
+};
+function assertNoExistingSource(existing) {
+  if (existing !== void 0) {
+    throw new Error("Cannot combine --file, --github, --local, and --url flags");
+  }
+}
+function parseGitHubArg(value) {
+  const atIndex = value.lastIndexOf("@");
+  if (atIndex === -1) {
+    return { repo: value, ref: "main" };
+  }
+  const repo = value.slice(0, atIndex);
+  const ref = value.slice(atIndex + 1);
+  if (ref === "") {
+    throw new Error(`Invalid --github value: ref after '@' must not be empty in "${value}"`);
+  }
+  return { repo, ref };
+}
+function parseSeverityFlag(flagName, value) {
+  if (!VALID_SEVERITIES.has(value)) {
+    throw new Error(`${flagName} must be one of: error, warn, recommend (got "${value}")`);
+  }
+  if (value === "error") return "error";
+  if (value === "warn") return "warn";
+  return "recommend";
+}
+const KITS_DIR = ".rdy/kits";
+function buildGitHubKitUrl(repo, ref, kit) {
+  return `https://raw.githubusercontent.com/${repo}/${ref}/${KITS_DIR}/${kit}.js`;
+}
+const flagErrorHints = {
+  "--kit": "--kit requires a kit name",
+  "--fail-on": "--fail-on requires a severity level (error, warn, recommend)",
+  "--file": "--file requires a path argument",
+  "--github": "--github requires a repository argument (org/repo[@ref])",
+  "--local": "--local requires a path to a local repository",
+  "--report-on": "--report-on requires a severity level (error, warn, recommend)",
+  "--url": "--url requires a URL argument"
+};
+function translateParseError(error) {
+  if (error instanceof Error) {
+    const match = error.message.match(/^(--\S+) requires a value$/);
+    if (match?.[1] !== void 0) {
+      const hint = flagErrorHints[match[1]];
+      if (hint !== void 0) {
+        throw new Error(hint);
+      }
+    }
+  }
+  throw error;
+}
+function parseRunArgs(flags) {
+  let result;
+  try {
+    result = parseArgs(flags, runFlagSchema);
+  } catch (error) {
+    translateParseError(error);
+  }
+  const { flags: parsed, positionals } = result;
+  let sourceType;
+  if (parsed.file !== void 0) {
+    assertNoExistingSource(sourceType);
+    sourceType = "file";
+  }
+  if (parsed.github !== void 0) {
+    assertNoExistingSource(sourceType);
+    sourceType = "github";
+  }
+  if (parsed.local !== void 0) {
+    assertNoExistingSource(sourceType);
+    sourceType = "local";
+  }
+  if (parsed.url !== void 0) {
+    assertNoExistingSource(sourceType);
+    sourceType = "url";
+  }
+  const failOn = parsed.failOn !== void 0 ? parseSeverityFlag("--fail-on", parsed.failOn) : void 0;
+  const reportOn = parsed.reportOn !== void 0 ? parseSeverityFlag("--report-on", parsed.reportOn) : void 0;
+  const parsedArgs = {
+    kitName: parsed.kit,
+    filePath: parsed.file,
+    githubValue: parsed.github,
+    json: parsed.json,
+    localValue: parsed.local,
+    names: positionals,
+    urlValue: parsed.url
+  };
+  if (failOn !== void 0) parsedArgs.failOn = failOn;
+  if (reportOn !== void 0) parsedArgs.reportOn = reportOn;
+  return parsedArgs;
+}
+function resolveKitSource({
+  filePath,
+  githubValue,
+  localValue,
+  urlValue,
+  kitName,
+  internalDir,
+  internalExtension
+}) {
+  if (filePath !== void 0) {
+    if (kitName !== void 0) {
+      throw new Error("--kit cannot be used with --file");
+    }
+    return { path: filePath };
+  }
+  if (githubValue !== void 0) {
+    const name2 = kitName ?? "default";
+    const { repo, ref } = parseGitHubArg(githubValue);
+    return { url: buildGitHubKitUrl(repo, ref, name2) };
+  }
+  if (localValue !== void 0) {
+    const name2 = kitName ?? "default";
+    const resolvedBase = path.resolve(process.cwd(), localValue);
+    return { path: path.join(resolvedBase, KITS_DIR, `${name2}.js`) };
+  }
+  if (urlValue !== void 0) {
+    if (kitName !== void 0) {
+      throw new Error("--kit cannot be used with --url");
+    }
+    return { url: urlValue };
+  }
+  const name = kitName ?? "default";
+  return { path: path.join(KITS_DIR, internalDir, `${name}${internalExtension}`) };
+}
+function resolveFixLocation(checklist, kitDefault) {
+  return checklist.fixLocation ?? kitDefault ?? "end";
+}
+function summarizeReport(name, report, reportOn) {
+  let passed = 0;
+  let failed = 0;
+  let skipped = 0;
+  for (const r of report.results) {
+    if (!meetsThreshold(r.severity, reportOn)) continue;
+    if (r.status === "passed") passed++;
+    else if (r.status === "failed") failed++;
+    else skipped++;
+  }
+  return { name, passed, failed, skipped, allPassed: report.passed, durationMs: report.durationMs };
+}
+function resolveThresholds(kit, cliFailOn, cliReportOn) {
+  return {
+    defaultSeverity: kit.defaultSeverity ?? "error",
+    failOn: cliFailOn ?? kit.failOn ?? "error",
+    reportOn: cliReportOn ?? kit.reportOn ?? "recommend"
+  };
+}
+async function loadKit(source) {
+  if ("url" in source) {
+    const options = { url: source.url };
+    if (source.url.includes("raw.githubusercontent.com")) {
+      const token = resolveGitHubToken();
+      if (token !== void 0) {
+        options.token = token;
+      }
+    }
+    return loadRemoteKit(options);
+  }
+  return loadRdyKit(source.path);
+}
+async function runCommand({ names, kitSource, json, failOn, reportOn }) {
+  let kit;
+  try {
+    kit = await loadKit(kitSource);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (json) {
+      process.stdout.write(formatJsonError(message) + "\n");
+    } else {
+      process.stderr.write(`Error: ${message}
+`);
+    }
+    return 1;
+  }
+  return runSingleKit(kit, names, json, failOn, reportOn);
+}
+async function runSingleKit(kit, names, json, failOn, reportOn) {
+  let resolvedNames;
+  try {
+    resolvedNames = resolveRequestedNames(names, kit);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (json) {
+      process.stdout.write(formatJsonError(message) + "\n");
+    } else {
+      process.stderr.write(`Error: ${message}
+`);
+    }
+    return 1;
+  }
+  const checklistByName = new Map(kit.checklists.map((c) => [c.name, c]));
+  const checklists = resolvedNames.flatMap((name) => {
+    const checklist = checklistByName.get(name);
+    return checklist !== void 0 ? [checklist] : [];
+  });
+  const thresholds = resolveThresholds(kit, failOn, reportOn);
+  if (json) {
+    return runJsonMode(checklists, thresholds);
+  }
+  return runHumanMode(checklists, kit, thresholds);
+}
+async function runJsonMode(checklists, thresholds) {
+  const entries = [];
+  let allPassed = true;
+  try {
+    for (const checklist of checklists) {
+      const report = await runRdy(checklist, {
+        defaultSeverity: thresholds.defaultSeverity,
+        failOn: thresholds.failOn
+      });
+      entries.push({ name: checklist.name, report });
+      if (!report.passed) allPassed = false;
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stdout.write(formatJsonError(message) + "\n");
+    return 1;
+  }
+  process.stdout.write(formatJsonReport(entries, { reportOn: thresholds.reportOn }) + "\n");
+  return allPassed ? 0 : 1;
+}
+async function runHumanMode(checklists, kit, thresholds) {
+  const showHeader = checklists.length > 1;
+  let allPassed = true;
+  const summaries = [];
+  try {
+    for (const checklist of checklists) {
+      if (showHeader) {
+        process.stdout.write(`
+--- ${checklist.name} ---
+
+`);
+      }
+      const report = await runRdy(checklist, {
+        defaultSeverity: thresholds.defaultSeverity,
+        failOn: thresholds.failOn
+      });
+      const fixLocation = resolveFixLocation(checklist, kit.fixLocation);
+      const output = reportRdy(report, { fixLocation, reportOn: thresholds.reportOn });
+      process.stdout.write(output + "\n");
+      if (!report.passed) {
+        allPassed = false;
+      }
+      if (showHeader) {
+        summaries.push(summarizeReport(checklist.name, report, thresholds.reportOn));
+      }
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`Error: ${message}
+`);
+    return 1;
+  }
+  if (summaries.length > 1) {
+    process.stdout.write("\n" + formatCombinedSummary(summaries) + "\n");
+  }
+  return allPassed ? 0 : 1;
+}
+export {
+  parseRunArgs,
+  resolveKitSource,
+  runCommand
+};

package/dist/esm/compile/compileCommand.d.ts

@@ -0,0 +1 @@
+export declare function compileCommand(args: string[]): Promise<number>;

package/dist/esm/compile/compileCommand.js

@@ -0,0 +1,121 @@
+import { existsSync, readdirSync } from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import picomatch from "picomatch";
+import { loadConfig } from "../loadConfig.js";
+import { parseArgs, translateParseError } from "../parseArgs.js";
+import { compileConfig } from "./compileConfig.js";
+import { validateCompiledOutput } from "./validateCompiledOutput.js";
+const compileFlagSchema = {
+  output: { long: "--output", type: "string", short: "-o" }
+};
+async function compileCommand(args) {
+  let parsed;
+  try {
+    parsed = parseArgs(args, compileFlagSchema);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message === "--output requires a value") {
+      process.stderr.write("Error: --output requires a path argument\n");
+    } else {
+      process.stderr.write(`Error: ${translateParseError(error)}
+`);
+    }
+    return 1;
+  }
+  const outputPath = parsed.flags.output;
+  const positionals = parsed.positionals;
+  if (positionals.length > 1) {
+    process.stderr.write("Error: Too many arguments. Expected a single input file.\n");
+    return 1;
+  }
+  const inputPath = positionals[0];
+  if (inputPath !== void 0) {
+    try {
+      const result = await compileConfig(inputPath, outputPath);
+      await validateCompiledOutput(result.outputPath);
+      const relInput = path.relative(process.cwd(), path.resolve(inputPath));
+      const relOutput = path.relative(process.cwd(), result.outputPath);
+      process.stdout.write("Compiling kit:\n");
+      process.stdout.write(formatResultLine(relInput, relOutput, result.changed));
+      return 0;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      process.stderr.write(`Error: ${message}
+`);
+      return 1;
+    }
+  }
+  if (outputPath !== void 0) {
+    process.stderr.write("Error: --output requires an input file\n");
+    return 1;
+  }
+  return compileBatch();
+}
+function collectSourceFiles(srcDir, includeGlob) {
+  const entries = readdirSync(srcDir, { recursive: true, encoding: "utf8" });
+  const isMatch = includeGlob !== void 0 ? picomatch(includeGlob) : void 0;
+  return entries.filter((name) => name.endsWith(".ts") && (isMatch === void 0 || isMatch(name))).sort();
+}
+async function compileBatch() {
+  let config;
+  try {
+    config = await loadConfig();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`Error: ${message}
+`);
+    return 1;
+  }
+  const srcDir = path.resolve(process.cwd(), config.compile.srcDir);
+  const outDir = path.resolve(process.cwd(), config.compile.outDir);
+  if (!existsSync(srcDir)) {
+    process.stderr.write(`Error: Source directory not found: ${srcDir}
+`);
+    return 1;
+  }
+  let tsFiles;
+  try {
+    tsFiles = collectSourceFiles(srcDir, config.compile.include);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`Error: Failed to read source directory: ${message}
+`);
+    return 1;
+  }
+  if (tsFiles.length === 0) {
+    process.stderr.write(`Error: No .ts files found in ${srcDir}
+`);
+    return 1;
+  }
+  const relSrcDir = path.relative(process.cwd(), srcDir);
+  const relOutDir = path.relative(process.cwd(), outDir);
+  const header = srcDir === outDir ? `Compiling kits in ${relSrcDir}:
+` : `Compiling kits from ${relSrcDir} to ${relOutDir}:
+`;
+  process.stdout.write(header);
+  for (const fileName of tsFiles) {
+    const srcFile = path.join(srcDir, fileName);
+    const outFile = path.join(outDir, fileName.replace(/\.ts$/, ".js"));
+    try {
+      const result = await compileConfig(srcFile, outFile);
+      await validateCompiledOutput(result.outputPath);
+      const outName = fileName.replace(/\.ts$/, ".js");
+      process.stdout.write(formatResultLine(fileName, outName, result.changed));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      process.stderr.write(`Error compiling ${fileName}: ${message}
+`);
+      return 1;
+    }
+  }
+  return 0;
+}
+function formatResultLine(srcName, outName, changed) {
+  return changed ? `  \u{1F4E6} ${srcName} \u2192 ${outName}
+` : `  \u26AA ${srcName} \u2014 no changes
+`;
+}
+export {
+  compileCommand
+};

package/dist/esm/compile/compileConfig.d.ts

@@ -0,0 +1,5 @@
+export interface CompileResult {
+    outputPath: string;
+    changed: boolean;
+}
+export declare function compileConfig(inputPath: string, outputPath?: string): Promise<CompileResult>;

package/dist/esm/compile/compileConfig.js

@@ -0,0 +1,52 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+const GENERATED_HEADER = [
+  "/** @noformat \u2014 @generated. Do not edit. Compiled by rdy. */",
+  "/* eslint-disable */",
+  ""
+].join("\n");
+function deriveOutputPath(inputPath) {
+  const ext = path.extname(inputPath);
+  if (ext === ".ts" || ext === ".mts" || ext === ".cts") {
+    return inputPath.slice(0, -ext.length) + ".js";
+  }
+  return `${inputPath}.js`;
+}
+async function compileConfig(inputPath, outputPath) {
+  const resolvedInput = path.resolve(inputPath);
+  const resolvedOutput = path.resolve(outputPath ?? deriveOutputPath(inputPath));
+  let esbuild;
+  try {
+    esbuild = await import("esbuild");
+  } catch (error) {
+    throw new Error(
+      "esbuild is required for the compile command but is not installed. Install it with: pnpm add --save-dev esbuild",
+      { cause: error }
+    );
+  }
+  const result = await esbuild.build({
+    entryPoints: [resolvedInput],
+    bundle: true,
+    format: "esm",
+    platform: "node",
+    target: "es2022",
+    external: ["node:*"],
+    banner: { js: GENERATED_HEADER },
+    write: false
+  });
+  const outputFile = result.outputFiles[0];
+  if (outputFile === void 0) {
+    throw new Error(`esbuild produced no output for ${resolvedInput}`);
+  }
+  const compiled = Buffer.from(outputFile.contents);
+  const existing = existsSync(resolvedOutput) ? readFileSync(resolvedOutput) : void 0;
+  const changed = existing === void 0 || !compiled.equals(existing);
+  if (changed) {
+    mkdirSync(path.dirname(resolvedOutput), { recursive: true });
+    writeFileSync(resolvedOutput, compiled);
+  }
+  return { outputPath: resolvedOutput, changed };
+}
+export {
+  compileConfig
+};

package/dist/esm/compile/validateCompiledOutput.d.ts

@@ -0,0 +1 @@
+export declare function validateCompiledOutput(outputPath: string): Promise<void>;

package/dist/esm/compile/validateCompiledOutput.js

@@ -0,0 +1,29 @@
+import { rmSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+import { assertIsRdyKit } from "../assertIsRdyKit.js";
+import { isRecord } from "../isRecord.js";
+import { resolveKitExports } from "../resolveKitExports.js";
+import { validateKit } from "../validateKit.js";
+async function validateCompiledOutput(outputPath) {
+  const fileUrl = `${pathToFileURL(outputPath).href}?t=${Date.now()}`;
+  let imported;
+  try {
+    imported = await import(fileUrl);
+  } catch (error) {
+    rmSync(outputPath, { force: true });
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to load compiled output for validation: ${detail}`);
+  }
+  const moduleRecord = isRecord(imported) ? imported : {};
+  try {
+    const resolved = resolveKitExports(moduleRecord);
+    assertIsRdyKit(resolved);
+    validateKit(resolved);
+  } catch (error) {
+    rmSync(outputPath, { force: true });
+    throw error;
+  }
+}
+export {
+  validateCompiledOutput
+};

package/dist/esm/config.d.ts

@@ -0,0 +1,2 @@
+import type { RdyKit } from './types.ts';
+export declare function loadRdyKit(kitPath: string): Promise<RdyKit>;

package/dist/esm/config.js

@@ -0,0 +1,28 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { assertIsRdyKit } from "./assertIsRdyKit.js";
+import { jitiImport } from "./jitiImport.js";
+import { resolveKitExports } from "./resolveKitExports.js";
+import { validateKit } from "./validateKit.js";
+async function loadRdyKit(kitPath) {
+  const resolvedPath = path.resolve(process.cwd(), kitPath);
+  if (!existsSync(resolvedPath)) {
+    if (kitPath.startsWith(".rdy/kits/")) {
+      const baseName = path.basename(kitPath, ".ts");
+      throw new Error(`Kit "${baseName}" not found. Run 'rdy init' to create one.`);
+    }
+    throw new Error(`Kit not found: ${kitPath}`);
+  }
+  const imported = await jitiImport(
+    resolvedPath,
+    "Uncompiled kits require the package to be installed as a project dependency. Alternatively, run 'rdy compile' to produce a self-contained bundle that does not need a local install.",
+    "Kit file"
+  );
+  const resolved = resolveKitExports(imported);
+  assertIsRdyKit(resolved);
+  validateKit(resolved);
+  return resolved;
+}
+export {
+  loadRdyKit
+};

package/dist/esm/expandGitHubShorthand.d.ts

@@ -0,0 +1 @@
+export declare function expandGitHubShorthand(shorthand: string): string;

package/dist/esm/expandGitHubShorthand.js

@@ -0,0 +1,26 @@
+function expandGitHubShorthand(shorthand) {
+  const atIndex = shorthand.lastIndexOf("@");
+  let pathPart;
+  let ref;
+  if (atIndex === -1) {
+    pathPart = shorthand;
+    ref = "main";
+  } else {
+    pathPart = shorthand.slice(0, atIndex);
+    ref = shorthand.slice(atIndex + 1);
+    if (ref === "") {
+      throw new Error(`Invalid GitHub shorthand: ref after '@' must not be empty in "${shorthand}"`);
+    }
+  }
+  const segments = pathPart.split("/");
+  if (segments.length < 3) {
+    throw new Error(`Invalid GitHub shorthand: expected at least "org/repo/file", got "${shorthand}"`);
+  }
+  const org = segments[0];
+  const repo = segments[1];
+  const filePath = segments.slice(2).join("/");
+  return `https://raw.githubusercontent.com/${org}/${repo}/${ref}/${filePath}`;
+}
+export {
+  expandGitHubShorthand
+};

package/dist/esm/formatCombinedSummary.d.ts

@@ -0,0 +1,2 @@
+import type { ChecklistSummary } from './types.ts';
+export declare function formatCombinedSummary(summaries: ChecklistSummary[]): string;

package/dist/esm/formatCombinedSummary.js

@@ -0,0 +1,40 @@
+import { formatSummaryCounts } from "./reportRdy.js";
+const ICON_PASSED = "\u{1F7E2}";
+const ICON_FAILED = "\u{1F534}";
+function formatDuration(ms) {
+  return `${Math.round(ms)}ms`;
+}
+function formatRowCounts(summary) {
+  const parts = [];
+  if (summary.passed > 0) parts.push(`${summary.passed} passed`);
+  if (summary.failed > 0) parts.push(`${summary.failed} failed`);
+  if (summary.skipped > 0) parts.push(`${summary.skipped} skipped`);
+  return parts.join(", ");
+}
+function formatCombinedSummary(summaries) {
+  const HEADER = "\u2500\u2500 Summary \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500";
+  const lines = [HEADER];
+  const maxNameLen = Math.max(...summaries.map((s) => s.name.length));
+  const maxDurationLen = Math.max(...summaries.map((s) => formatDuration(s.durationMs).length));
+  for (const summary of summaries) {
+    const icon = summary.allPassed ? ICON_PASSED : ICON_FAILED;
+    const name = summary.name.padEnd(maxNameLen);
+    const duration = formatDuration(summary.durationMs).padStart(maxDurationLen);
+    const counts = formatRowCounts(summary);
+    lines.push(`${icon} ${name}  ${duration}  ${counts}`);
+  }
+  lines.push(
+    "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"
+  );
+  const totalPassed = summaries.reduce((sum, s) => sum + s.passed, 0);
+  const totalFailed = summaries.reduce((sum, s) => sum + s.failed, 0);
+  const totalSkipped = summaries.reduce((sum, s) => sum + s.skipped, 0);
+  const totalDuration = summaries.reduce((sum, s) => sum + s.durationMs, 0);
+  lines.push(
+    `Total: ${formatSummaryCounts(totalPassed, totalFailed, totalSkipped)} (${formatDuration(totalDuration)})`
+  );
+  return lines.join("\n");
+}
+export {
+  formatCombinedSummary
+};

package/dist/esm/formatJsonError.d.ts

@@ -0,0 +1 @@
+export declare function formatJsonError(message: string): string;

package/dist/esm/formatJsonError.js

@@ -0,0 +1,6 @@
+function formatJsonError(message) {
+  return JSON.stringify({ error: message });
+}
+export {
+  formatJsonError
+};

package/dist/esm/formatJsonReport.d.ts

@@ -0,0 +1,10 @@
+import type { RdyReport, Severity } from './types.ts';
+interface ChecklistEntry {
+    name: string;
+    report: RdyReport;
+}
+export interface FormatJsonReportOptions {
+    reportOn?: Severity;
+}
+export declare function formatJsonReport(entries: ChecklistEntry[], options?: FormatJsonReportOptions): string;
+export {};