@alis-build/harness-eval 0.1.0

package/dist/cli/bin.js

@@ -0,0 +1,623 @@
+#!/usr/bin/env node
+import { C as gradeReport, O as trajectoryToOtlp, S as resolveGradeOptions, a as toProtoInstances, b as formatGradingConsole, i as toAgentTrace, n as buildEvalRunEnvelopeFromFiles, o as toTrajectory, w as loadSuiteReport, x as gradingReportPassed, y as formatReport } from "../build-DsVJ_UeU.js";
+import { t as runSuite, u as getAdapter } from "../suite-chj0j22j.js";
+import { i as loadGradingConfig, t as loadSuite } from "../loader-BCnFJ8rm.js";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/cli/args.ts
+function parseArgs(argv) {
+	const positional = [];
+	const options = {};
+	let command;
+	const args = [...argv];
+	if (args.length > 0 && !args[0].startsWith("-")) command = args.shift();
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "--") {
+			positional.push(...args.slice(i + 1));
+			break;
+		}
+		if (arg.startsWith("--")) {
+			const key = arg.slice(2);
+			const next = args[i + 1];
+			if (next && !next.startsWith("-")) {
+				options[key] = next;
+				i++;
+			} else options[key] = true;
+		} else if (arg.startsWith("-") && arg.length === 2) {
+			const key = arg.slice(1);
+			const next = args[i + 1];
+			if (next && !next.startsWith("-")) {
+				options[key] = next;
+				i++;
+			} else options[key] = true;
+		} else positional.push(arg);
+	}
+	return {
+		command,
+		positional,
+		options
+	};
+}
+function getOption(options, name) {
+	const v = options[name];
+	return typeof v === "string" ? v : void 0;
+}
+function getOptionInt(options, name, defaultValue) {
+	const v = getOption(options, name);
+	if (v === void 0) return defaultValue;
+	const n = Number.parseInt(v, 10);
+	if (!Number.isFinite(n)) return defaultValue;
+	return n;
+}
+function hasOption(options, name) {
+	const v = options[name];
+	return v === true || typeof v === "string" && v === "true";
+}
+//#endregion
+//#region src/cli/commands/envelope.ts
+/**
+* `harness-eval envelope` — build EvalRunEnvelope and interchange projections.
+*/
+const PROJECTIONS = /* @__PURE__ */ new Set([
+	"envelope",
+	"trajectory",
+	"instances",
+	"agent-trace"
+]);
+function parseEnvelopeProjection(value) {
+	if (value === void 0) return "envelope";
+	if (PROJECTIONS.has(value)) return value;
+}
+function serializeEnvelopeProjection(envelope, projection) {
+	switch (projection) {
+		case "trajectory": return `${toTrajectory(envelope).map((row) => JSON.stringify(row)).join("\n")}\n`;
+		case "instances": return `${JSON.stringify(toProtoInstances(envelope), null, 2)}\n`;
+		case "agent-trace": return `${JSON.stringify(toAgentTrace(envelope), null, 2)}\n`;
+		default: return `${JSON.stringify(envelope, null, 2)}\n`;
+	}
+}
+async function readFrameworkVersion() {
+	try {
+		const text = await readFile(join(dirname(fileURLToPath(import.meta.url)), "../../../package.json"), "utf8");
+		return JSON.parse(text).version;
+	} catch {
+		return;
+	}
+}
+async function envelopeCommand(args) {
+	const reportPath = args.positional[0];
+	if (!reportPath) {
+		console.error("usage: harness-eval envelope <report.json> [--output path] [--grading path] [--suite path] [--projection envelope|trajectory|instances|agent-trace] [--include-raw-stream-events] [--no-transcript]");
+		return 2;
+	}
+	const outputPath = getOption(args.options, "output");
+	const gradingPath = getOption(args.options, "grading");
+	const suitePath = getOption(args.options, "suite");
+	const projection = parseEnvelopeProjection(getOption(args.options, "projection"));
+	if (!projection) {
+		console.error("invalid --projection; expected envelope, trajectory, instances, or agent-trace");
+		return 2;
+	}
+	let envelope;
+	try {
+		const frameworkVersion = await readFrameworkVersion();
+		envelope = await buildEvalRunEnvelopeFromFiles(reportPath, {
+			gradingPath,
+			suitePath,
+			includeTranscript: !hasOption(args.options, "no-transcript"),
+			includeRawStreamEvents: hasOption(args.options, "include-raw-stream-events"),
+			harness: { frameworkVersion }
+		});
+	} catch (err) {
+		console.error(err instanceof Error ? err.message : String(err));
+		return 2;
+	}
+	const serialized = serializeEnvelopeProjection(envelope, projection);
+	if (outputPath) await writeFile(outputPath, serialized, "utf8");
+	else process.stdout.write(serialized);
+	return envelope.summary.behavioralPass ? 0 : 1;
+}
+//#endregion
+//#region src/cli/commands/format.ts
+/**
+* `harness-eval format` command.
+*/
+async function formatCommand(args) {
+	const reportPath = args.positional[0];
+	if (!reportPath) {
+		console.error("usage: harness-eval format <report.json> [options]");
+		return 2;
+	}
+	const format = getOption(args.options, "format") ?? "console";
+	const baselinePath = getOption(args.options, "baseline");
+	let report;
+	try {
+		report = JSON.parse(await readFile(reportPath, "utf8"));
+	} catch (err) {
+		console.error(err instanceof Error ? err.message : String(err));
+		return 2;
+	}
+	let baseline;
+	if (baselinePath) baseline = JSON.parse(await readFile(baselinePath, "utf8"));
+	const formatted = formatReport(report, {
+		format: format === "markdown" || format === "json" ? format : "console",
+		baseline,
+		color: format === "console"
+	});
+	process.stdout.write(formatted);
+	if (!formatted.endsWith("\n")) process.stdout.write("\n");
+	return report.cells.every((c) => c.passed) ? 0 : 1;
+}
+//#endregion
+//#region src/cli/progress.ts
+const GREEN = "\x1B[32m";
+const RED = "\x1B[31m";
+const YELLOW = "\x1B[33m";
+const DIM = "\x1B[2m";
+const RESET = "\x1B[0m";
+function resolveProgressMode(options) {
+	const progress = getOption(options, "progress");
+	if (progress === "json" || progress === "quiet" || progress === "verbose" || progress === "default") return progress;
+	if (hasOption(options, "quiet")) return "quiet";
+	if (hasOption(options, "verbose")) return "verbose";
+	return "default";
+}
+/** Whether to emit ANSI colors on the progress stream (stderr). */
+function resolveProgressColor(options, stream = process.stderr) {
+	if (hasOption(options, "no-color")) return false;
+	if (hasOption(options, "color")) return true;
+	if (process.env.NO_COLOR !== void 0 && process.env.NO_COLOR !== "") return false;
+	if (process.env.FORCE_COLOR !== void 0 && process.env.FORCE_COLOR !== "0") return true;
+	return "isTTY" in stream && stream.isTTY === true;
+}
+function okMark(color) {
+	return color ? `${GREEN}✓${RESET}` : "✓";
+}
+function failMark(color) {
+	return color ? `${RED}✗${RESET}` : "✗";
+}
+function okStatus(color) {
+	return color ? `${GREEN}ok${RESET}` : "ok";
+}
+function failStatus(color) {
+	return color ? `${RED}FAIL${RESET}` : "FAIL";
+}
+function passLabel(color) {
+	return color ? `${GREEN}PASS${RESET}` : "PASS";
+}
+function failLabel(color) {
+	return color ? `${RED}FAIL${RESET}` : "FAIL";
+}
+function createRunProgressHandler(options) {
+	const stream = options.stream ?? process.stderr;
+	const mode = options.mode;
+	const color = options.color ?? false;
+	let totalReps = 0;
+	let completed = 0;
+	let totalDurationMs = 0;
+	return (event) => {
+		switch (event.kind) {
+			case "suite-start":
+				totalReps = event.totalReps;
+				completed = 0;
+				totalDurationMs = 0;
+				if (mode === "quiet") return;
+				if (mode === "json") {
+					writeJson(stream, {
+						kind: "suite-start",
+						totalReps: event.totalReps,
+						maxConcurrent: options.maxConcurrent
+					});
+					return;
+				}
+				const concurrent = options.maxConcurrent !== void 0 ? ` (max-concurrent ${options.maxConcurrent})` : "";
+				stream.write(`Running ${totalReps} repetitions${concurrent}...\n\n`);
+				break;
+			case "rep-complete":
+				completed++;
+				totalDurationMs += event.durationMs;
+				if (mode === "quiet") {
+					stream.write(event.ok ? color ? `${GREEN}.${RESET}` : "." : color ? `${RED}x${RESET}` : "x");
+					return;
+				}
+				if (mode === "json") {
+					writeJson(stream, {
+						kind: "rep-complete",
+						index: completed,
+						total: totalReps,
+						caseId: event.caseId,
+						cellLabel: event.cellLabel,
+						repIndex: event.repIndex,
+						ok: event.ok,
+						durationMs: event.durationMs,
+						toolCallCount: event.toolCallCount,
+						errorMessage: event.errorMessage
+					});
+					return;
+				}
+				const eta = formatEta(totalDurationMs, completed, totalReps);
+				const icon = event.ok ? okMark(color) : failMark(color);
+				const status = event.ok ? okStatus(color) : failStatus(color);
+				let line = `${icon} [${completed}/${totalReps}] ${event.caseId} @ ${event.cellLabel} #${event.repIndex}  ${status}  ${formatDuration(event.durationMs)}`;
+				if (eta) line += color ? `  ${DIM}(${eta})${RESET}` : `  (${eta})`;
+				if (!event.ok && event.errorMessage) line += color ? `  ${YELLOW}— ${truncate(event.errorMessage, 80)}${RESET}` : `  — ${truncate(event.errorMessage, 80)}`;
+				if (mode === "verbose") {
+					if (event.toolCallCount !== void 0) line += `  tools=${event.toolCallCount}`;
+					const summary = formatAssertionSummary(event.assertionResults, color);
+					if (summary) line += `  ${summary}`;
+				}
+				stream.write(`${line}\n`);
+				break;
+			case "cell-complete":
+				if (mode === "quiet") return;
+				if (mode === "json") {
+					writeJson(stream, {
+						kind: "cell-complete",
+						caseId: event.report.caseId,
+						cellLabel: event.report.cell.label,
+						passed: event.report.passed,
+						adapterErrors: event.report.adapterErrors,
+						assertionStats: event.report.assertionStats.map((s) => ({
+							description: s.description,
+							passRate: s.passRate,
+							meetsThreshold: s.meetsThreshold
+						}))
+					});
+					return;
+				}
+				stream.write(`${formatCellSummary(event.report, color)}\n`);
+				break;
+			case "suite-complete":
+				if (mode === "quiet") {
+					stream.write("\n");
+					return;
+				}
+				if (mode === "json") {
+					writeJson(stream, {
+						kind: "suite-complete",
+						durationMs: event.report.durationMs,
+						cellsTotal: event.report.cells.length,
+						cellsPassed: event.report.cells.filter((c) => c.passed).length
+					});
+					return;
+				}
+				const okReps = event.report.cells.reduce((n, c) => n + c.repetitions.filter((r) => r.error === null).length, 0);
+				const totalRun = event.report.cells.reduce((n, c) => n + c.repetitions.length, 0);
+				const adapterErrors = event.report.cells.reduce((n, c) => n + c.adapterErrors, 0);
+				let footer = `\nFinished in ${formatDuration(event.report.durationMs)} (${okReps}/${totalRun} reps ok`;
+				if (adapterErrors > 0) footer += `, ${adapterErrors} adapter error(s)`;
+				footer += ")\n\n";
+				stream.write(footer);
+				break;
+			default: break;
+		}
+	};
+}
+function createGradeProgressHandler(options) {
+	const stream = options.stream ?? process.stderr;
+	const mode = options.mode;
+	const color = options.color ?? false;
+	let total = 0;
+	let completed = 0;
+	let totalDurationMs = 0;
+	return (event) => {
+		switch (event.kind) {
+			case "grade-start":
+				total = event.total;
+				completed = 0;
+				totalDurationMs = 0;
+				if (mode === "quiet" || total === 0) return;
+				if (mode === "json") {
+					writeJson(stream, {
+						kind: "grade-start",
+						total: event.total,
+						maxConcurrent: options.maxConcurrent
+					});
+					return;
+				}
+				const concurrent = options.maxConcurrent !== void 0 ? ` (max-concurrent ${options.maxConcurrent})` : "";
+				stream.write(`Grading ${total} repetition(s)${concurrent}...\n\n`);
+				break;
+			case "grade-complete":
+				completed++;
+				totalDurationMs += event.durationMs;
+				if (mode === "quiet") {
+					const allPassed = event.failed === 0 && !event.graderError;
+					stream.write(allPassed ? color ? `${GREEN}.${RESET}` : "." : color ? `${RED}x${RESET}` : "x");
+					return;
+				}
+				if (mode === "json") {
+					writeJson(stream, {
+						kind: "grade-complete",
+						index: completed,
+						total,
+						caseId: event.caseId,
+						cellLabel: event.cellLabel,
+						repetitionIndex: event.repetitionIndex,
+						passed: event.passed,
+						failed: event.failed,
+						durationMs: event.durationMs,
+						graderError: event.graderError
+					});
+					return;
+				}
+				const eta = formatEta(totalDurationMs, completed, total);
+				const ok = event.failed === 0 && !event.graderError;
+				const icon = ok ? okMark(color) : failMark(color);
+				const status = ok ? okStatus(color) : failStatus(color);
+				let line = `${icon} [${completed}/${total}] ${event.caseId} @ ${event.cellLabel} #${event.repetitionIndex}  ${status}  ${formatDuration(event.durationMs)}`;
+				line += `  expectations ${event.passed}/${event.passed + event.failed}`;
+				if (eta) line += color ? `  ${DIM}(${eta})${RESET}` : `  (${eta})`;
+				if (event.graderError) line += color ? `  ${YELLOW}— ${truncate(event.graderError, 80)}${RESET}` : `  — ${truncate(event.graderError, 80)}`;
+				if (mode === "verbose" && event.failed && event.failed > 0) line += color ? `  ${YELLOW}see grading output${RESET}` : "  see grading output";
+				stream.write(`${line}\n`);
+				break;
+			case "grade-done":
+				if (mode === "quiet") {
+					stream.write("\n");
+					return;
+				}
+				if (mode === "json") {
+					writeJson(stream, {
+						kind: "grade-done",
+						durationMs: event.durationMs,
+						totalExpectations: event.totalExpectations,
+						passedExpectations: event.passedExpectations
+					});
+					return;
+				}
+				if (total === 0) return;
+				stream.write(`\nGraded in ${formatDuration(event.durationMs)} (${event.passedExpectations}/${event.totalExpectations} expectations passed)\n\n`);
+				break;
+			default: break;
+		}
+	};
+}
+function writeJson(stream, value) {
+	stream.write(`${JSON.stringify(value)}\n`);
+}
+function formatDuration(ms) {
+	if (ms < 1e3) return `${ms}ms`;
+	const sec = ms / 1e3;
+	if (sec < 60) return `${sec.toFixed(1)}s`;
+	const min = Math.floor(sec / 60);
+	const remSec = Math.round(sec % 60);
+	if (min < 60) return `${min}m ${remSec}s`;
+	return `${Math.floor(min / 60)}h ${min % 60}m`;
+}
+function formatEta(totalDurationMs, completed, total) {
+	if (completed === 0 || completed >= total) return void 0;
+	const avg = totalDurationMs / completed;
+	const remaining = (total - completed) * avg;
+	return `~${formatDuration(Math.round(remaining))} remaining`;
+}
+function truncate(text, max) {
+	if (text.length <= max) return text;
+	return `${text.slice(0, max - 1)}…`;
+}
+function formatAssertionSummary(results, color = false) {
+	if (!results || results.length === 0) return "";
+	return results.map((r) => `${r.passed ? okMark(color) : failMark(color)} ${r.description}`).join(", ");
+}
+function formatCellSummary(cell, color) {
+	const mark = cell.passed ? okMark(color) : failMark(color);
+	const status = cell.passed ? passLabel(color) : failLabel(color);
+	const parts = cell.assertionStats.map((s) => {
+		const pct = (s.passRate * 100).toFixed(0);
+		return `${s.description} ${s.passedCount}/${s.evaluatedCount} (${pct}%)`;
+	});
+	const crash = cell.adapterErrors > 0 ? color ? ` ${YELLOW}[${cell.adapterErrors} adapter errors]${RESET}` : ` [${cell.adapterErrors} adapter errors]` : "";
+	const stats = parts.length > 0 ? `  ${parts.join(" · ")}` : "";
+	return `${mark} ${cell.caseId} @ ${cell.cell.label}  ${status}${crash}${stats}`;
+}
+//#endregion
+//#region src/cli/commands/grade.ts
+/**
+* `harness-eval grade` — LLM outcome grading on a suite report.
+*/
+function optionalOptionInt(options, name) {
+	const raw = getOption(options, name);
+	if (raw === void 0) return void 0;
+	const n = Number.parseInt(raw, 10);
+	return Number.isFinite(n) ? n : void 0;
+}
+async function gradeCommand(args) {
+	const reportPath = args.positional[0];
+	if (!reportPath) {
+		console.error("usage: harness-eval grade <report.json> [--config grading.yaml] [--expectations path] [--output path] [--model id] [--timeout-ms N] [--max-concurrent N]");
+		return 2;
+	}
+	const configPath = getOption(args.options, "config");
+	const expectationsPath = getOption(args.options, "expectations");
+	const outputPath = getOption(args.options, "output");
+	const model = getOption(args.options, "model");
+	const binary = getOption(args.options, "binary");
+	const timeoutMs = optionalOptionInt(args.options, "timeout-ms");
+	const maxConcurrent = getOption(args.options, "max-concurrent") ? getOptionInt(args.options, "max-concurrent", 2) : void 0;
+	const format = getOption(args.options, "format") ?? "console";
+	const progressMode = resolveProgressMode(args.options);
+	const useProgressColor = progressMode !== "json" && resolveProgressColor(args.options);
+	let fileConfig;
+	if (configPath) try {
+		fileConfig = await loadGradingConfig(configPath);
+	} catch (err) {
+		console.error(err instanceof Error ? err.message : String(err));
+		return 2;
+	}
+	let report;
+	try {
+		report = await loadSuiteReport(reportPath);
+	} catch (err) {
+		console.error(err instanceof Error ? err.message : String(err));
+		return 2;
+	}
+	let gradeOptions;
+	try {
+		gradeOptions = resolveGradeOptions(fileConfig, {
+			sourceReport: reportPath,
+			expectationsPath,
+			model,
+			binary,
+			timeoutMs,
+			maxConcurrent
+		}, configPath);
+	} catch (err) {
+		console.error(err instanceof Error ? err.message : String(err));
+		return 2;
+	}
+	const onProgress = createGradeProgressHandler({
+		mode: progressMode,
+		maxConcurrent: gradeOptions.maxConcurrent ?? 2,
+		color: useProgressColor
+	});
+	const grading = await gradeReport(report, {
+		...gradeOptions,
+		onProgress
+	});
+	if (outputPath) await writeFile(outputPath, JSON.stringify(grading, null, 2), "utf8");
+	if (format === "json") {
+		process.stdout.write(JSON.stringify(grading, null, 2));
+		process.stdout.write("\n");
+	} else {
+		const formatted = formatGradingConsole(grading, format === "console");
+		process.stdout.write(formatted);
+		if (!formatted.endsWith("\n")) process.stdout.write("\n");
+	}
+	if (grading.results.length === 0) return 2;
+	return gradingReportPassed(grading) ? 0 : 1;
+}
+//#endregion
+//#region src/cli/commands/otel-output.ts
+/**
+* Write OTLP JSON artifacts from a suite report.
+*/
+function safeFilePart(value) {
+	return value.replace(/[^a-zA-Z0-9._-]+/g, "_");
+}
+/**
+* Write one OTLP JSON file per successful repetition.
+*
+* Files: `{caseId}__{cellLabel}__rep{N}.otlp.json`
+*/
+async function writeOtelArtifacts(suite, report, outputDir) {
+	await mkdir(outputDir, { recursive: true });
+	let written = 0;
+	for (const cellReport of report.cells) {
+		const testCase = suite.cases.find((c) => c.id === cellReport.caseId);
+		if (!testCase) continue;
+		for (const rep of cellReport.repetitions) {
+			if (!rep.adapterResult) continue;
+			const otlp = trajectoryToOtlp(rep.adapterResult.view, { prompt: testCase.prompt });
+			await writeFile(join(outputDir, `${safeFilePart(cellReport.caseId)}__${safeFilePart(cellReport.cell.label)}__rep${rep.repetitionIndex}.otlp.json`), JSON.stringify(otlp, null, 2), "utf8");
+			written++;
+		}
+	}
+	return written;
+}
+//#endregion
+//#region src/cli/commands/run.ts
+/**
+* `harness-eval run` command.
+*/
+async function runCommand(args) {
+	const suitePath = args.positional[0];
+	if (!suitePath) {
+		console.error("usage: harness-eval run <suite.yaml> [options]");
+		return 2;
+	}
+	const format = getOption(args.options, "format") ?? "console";
+	const outputPath = getOption(args.options, "output");
+	const otelOutputDir = getOption(args.options, "otel-output");
+	const baselinePath = getOption(args.options, "baseline");
+	const maxConcurrent = getOptionInt(args.options, "max-concurrent", 4);
+	const adapterId = getOption(args.options, "adapter");
+	const progressMode = resolveProgressMode(args.options);
+	const useProgressColor = progressMode !== "json" && resolveProgressColor(args.options);
+	let suite;
+	try {
+		suite = await loadSuite(suitePath);
+	} catch (err) {
+		console.error(err instanceof Error ? err.message : String(err));
+		return 2;
+	}
+	const adapter = getAdapter(adapterId ?? suite.adapter ?? "claude-code");
+	const onProgress = createRunProgressHandler({
+		mode: progressMode,
+		maxConcurrent,
+		color: useProgressColor
+	});
+	const report = await runSuite(suite, {
+		adapter,
+		maxConcurrent,
+		onProgress
+	});
+	if (outputPath) await writeFile(outputPath, JSON.stringify(report, null, 2), "utf8");
+	if (otelOutputDir) {
+		const count = await writeOtelArtifacts(suite, report, otelOutputDir);
+		process.stderr.write(`otel: wrote ${count} trace file(s) to ${otelOutputDir}\n`);
+	}
+	let baseline;
+	if (baselinePath) {
+		const { readFile } = await import("node:fs/promises");
+		baseline = JSON.parse(await readFile(baselinePath, "utf8"));
+	}
+	const formatted = formatReport(report, {
+		format: format === "markdown" || format === "json" ? format : "console",
+		baseline,
+		color: format === "console"
+	});
+	process.stdout.write(formatted);
+	if (!formatted.endsWith("\n")) process.stdout.write("\n");
+	return report.cells.every((c) => c.passed) ? 0 : 1;
+}
+//#endregion
+//#region src/cli/main.ts
+/**
+* CLI entry point.
+*/
+const USAGE = `harness-eval — harness-level eval framework
+
+Usage:
+  harness-eval run <suite.yaml> [--max-concurrent N] [--baseline path] [--output path] [--otel-output dir] [--format console|markdown|json] [--adapter id] [--quiet] [--verbose] [--progress default|quiet|verbose|json]
+  harness-eval grade <report.json> [--config grading.yaml] [--expectations path] [--output path] [--model id] [--timeout-ms N] [--max-concurrent N] [--format console|json] [--quiet] [--verbose] [--progress default|quiet|verbose|json]
+  harness-eval envelope <report.json> [--output path] [--grading path] [--suite path] [--projection envelope|trajectory|instances|agent-trace] [--include-raw-stream-events] [--no-transcript]
+  harness-eval format <report.json> [--format console|markdown|json] [--baseline path]
+  harness-eval --help
+
+  Progress (run & grade):
+  default   one line per repetition + per-cell summary (default)
+  --quiet   colored dots (. = ok, x = fail)
+  --verbose per-rep details (tool counts, assertion summary)
+  --progress json   newline-delimited JSON events on stderr
+  --no-color        disable ANSI colors on progress output
+  --color           force ANSI colors on progress output
+`;
+async function main(argv) {
+	const parsed = parseArgs(argv);
+	if (parsed.options.help || parsed.command === "help" || parsed.options.h) {
+		process.stdout.write(USAGE);
+		return 0;
+	}
+	switch (parsed.command) {
+		case "run": return await runCommand(parsed);
+		case "grade": return await gradeCommand(parsed);
+		case "envelope": return await envelopeCommand(parsed);
+		case "format": return await formatCommand(parsed);
+		case void 0:
+			console.error(USAGE);
+			return 2;
+		default:
+			console.error(`unknown command: ${parsed.command}\n\n${USAGE}`);
+			return 2;
+	}
+}
+//#endregion
+//#region src/cli/bin.ts
+const code = await main(process.argv.slice(2));
+process.exit(code);
+//#endregion
+export {};
+
+//# sourceMappingURL=bin.js.map