@siftline/cli 0.0.2 → 0.1.1

package/README.md

@@ -1,19 +1,36 @@
 # @siftline/cli
 
-The Siftline command line: measure a recipe against its fixtures, then label for real.
-
-This package is a walking skeleton. The `siftline` bin prints its version and a usage
-block; `test` and `label` are named there but not implemented, which is enough to prove
-the bin, shebang, build, type, test, pack and publish path. The commands land next.
+The Siftline command line: measure a Recipe against its Fixtures, then label for real.
 
 ```sh
-npx @siftline/cli --help
+npm install --save-dev @siftline/cli
+export TYPESAFE_API_KEY=...
+
+npx siftline test recipe.json fixtures.jsonl
+npx siftline label recipe.json records.jsonl --rules rules.json > decisions.jsonl
 ```
 
-Exit codes: `0` for `--help` and `--version`, `1` for anything else.
+```
+support-inbox v1 · jev-1.13.0
+
+category      4/5   0.80
+wants_human   5/5   1.00
+
+accuracy      0.80  (lowest question)
+unsure        1 of 5 would go to Review
+
+fixture:4  category: expected complaint, got question
+```
+
+`test` reports one accuracy per Question and fails CI with `--min-accuracy`. `label` writes
+one Decision line per Record, routed through Rules when `--rules` is given. `npx siftline --help`
+prints the rest.
+
+The guide, the options and the exit codes live at
+[docs.siftline.dev](https://docs.siftline.dev/docs/packages/cli).
 
 ESM only. Node 22.14 or newer.
 
 ## Licence
 
-MIT — see [LICENSE](./LICENSE).
+MIT. See [LICENSE](./LICENSE).

package/dist/cli.mjs

@@ -1,9 +1,22 @@
 #!/usr/bin/env node
-import { r as run } from "./src-DYu5d4UT.mjs";
+import { i as API_KEY_ENV, t as run } from "./src-Ci51FAD3.mjs";
+import { TypeSafeClient } from "@typesafe-ai/sdk";
 //#region src/cli.ts
-const result = run(process.argv.slice(2));
-if (result.stdout !== "") process.stdout.write(result.stdout);
-if (result.stderr !== "") process.stderr.write(result.stderr);
-process.exitCode = result.code;
+const controller = new AbortController();
+process.on("SIGINT", () => {
+	controller.abort();
+});
+let client;
+process.exitCode = await run(process.argv.slice(2), {
+	client: { systemOne: (request, options) => {
+		client ??= new TypeSafeClient({ apiKey: process.env[API_KEY_ENV] });
+		return client.systemOne(request, options);
+	} },
+	stdin: process.stdin,
+	stdout: process.stdout,
+	stderr: process.stderr,
+	env: process.env,
+	signal: controller.signal
+});
 //#endregion
 export {};

package/dist/index.d.mts

@@ -1,24 +1,37 @@
-//#region src/index.d.ts
-/**
- * The published version of `@siftline/cli`, baked in at build time.
- *
- * Changesets bumps `package.json`; this constant follows it without a second edit.
- */
+import { SystemOneClient } from "@siftline/core";
+//#region src/deps.d.ts
+/** `process.stdout` and `process.stderr` satisfy this, and so does a string buffer. */
+interface OutputStream {
+  write: (chunk: string) => void;
+  readonly isTTY?: boolean;
+}
+/** `process.stdin`, or any async iterable of chunks. */
+type InputStream = AsyncIterable<string | Uint8Array>;
+/** The CLI's only seam. The bin wires the process to it; tests wire strings. */
+interface RunDeps {
+  client: SystemOneClient;
+  stdin: InputStream;
+  stdout: OutputStream;
+  stderr: OutputStream;
+  env: {
+    readonly [name: string]: string | undefined;
+  };
+  signal?: AbortSignal;
+}
+//#endregion
+//#region src/options.d.ts
+export declare const API_KEY_ENV = "TYPESAFE_API_KEY";
+//#endregion
+//#region src/usage.d.ts
+/** The published version of `@siftline/cli`, baked in at build time. */
 export declare const VERSION: string;
-/**
- * The usage block. `test` and `label` are named before they exist so that the bin
- * wiring is proven — and so that `siftline --help` never lies about what it does.
- */
 export declare const USAGE: string;
-/** What one invocation produced: the text to write and the process exit code. */
-export interface CliResult {
-  readonly code: 0 | 1;
-  readonly stdout: string;
-  readonly stderr: string;
-}
+//#endregion
+//#region src/index.d.ts
 /**
- * Interpret command line arguments. Pure on purpose: the bin is the only place that
- * touches the process, so the behaviour stays testable without one.
+ * The library door. Every command runs through it, so a test drives the whole CLI with an
+ * injected client and string streams and asserts on the exit code and what was written.
  */
-export declare function run(argv: readonly string[]): CliResult;
-//#endregion
+export declare function run(argv: readonly string[], deps: RunDeps): Promise<number>;
+//#endregion
+export type { InputStream, OutputStream, RunDeps };

package/dist/index.mjs

@@ -1,2 +1,2 @@
-import { n as VERSION, r as run, t as USAGE } from "./src-DYu5d4UT.mjs";
-export { USAGE, VERSION, run };
+import { i as API_KEY_ENV, n as USAGE, r as VERSION, t as run } from "./src-Ci51FAD3.mjs";
+export { API_KEY_ENV, USAGE, VERSION, run };

package/dist/src-Ci51FAD3.mjs

@@ -0,0 +1,456 @@
+import { DEFAULT_MAX_IN_FLIGHT, JudgeError, SiftlineError, VERSION, createJudge, parseFixtures, parseRecipe, recordSchema, routeDecision, ruleSchema, serializeDecision, testRecipe, validateFixtures, validateRules } from "@siftline/core";
+import { readFile } from "node:fs/promises";
+import { z } from "zod";
+import { parseArgs } from "node:util";
+//#region src/deps.ts
+/** A bad invocation. Exit 2, with the usage block. */
+var UsageError = class extends Error {};
+/** A file the arguments named that could not be read or parsed. Exit 2, no usage block. */
+var InputError = class extends Error {};
+function writeLine(stream, line) {
+	stream.write(`${line}\n`);
+}
+//#endregion
+//#region src/input.ts
+async function readTextFile(path, what) {
+	try {
+		return await readFile(path, "utf8");
+	} catch (cause) {
+		throw new InputError(`cannot read the ${what} ${path}: ${reason(cause)}`, { cause });
+	}
+}
+async function readRecipeFile(path) {
+	const text = await readTextFile(path, "recipe");
+	try {
+		return parseRecipe(text);
+	} catch (cause) {
+		throw new InputError(`${path} is not a valid Recipe: ${reason(cause)}`, { cause });
+	}
+}
+async function readFixturesFile(path, recipe) {
+	return await readChecked(path, "fixtures", "Fixtures", parseFixtures, (fixtures) => validateFixtures(fixtures, recipe).map((problem) => `fixture ${problem.fixture}: ${problem.problem}`));
+}
+async function readRulesFile(path, recipe) {
+	return await readChecked(path, "rules", "Rules", (text) => ruleSchema.array().parse(JSON.parse(text)), (rules) => validateRules(rules, recipe).map((problem) => `rule ${problem.rule}: ${problem.problem}`));
+}
+/** Parse the whole file, then refuse it on the first line that no longer fits the Recipe. */
+async function readChecked(path, what, kind, parse, stale) {
+	const text = await readTextFile(path, what);
+	let items;
+	try {
+		items = parse(text);
+	} catch (cause) {
+		throw new InputError(`${path} does not hold valid ${kind}: ${reason(cause)}`, { cause });
+	}
+	const problems = stale(items);
+	const first = problems[0];
+	if (first) throw new InputError(`${path} does not fit the Recipe: ${first}${andMore(problems.length)}`);
+	return items;
+}
+/** `-` and an absent path both mean stdin. Every line is parsed before the caller judges any. */
+async function readRecords(path, stdin) {
+	const fromStdin = path === void 0 || path === "-";
+	const source = fromStdin ? "stdin" : path;
+	const text = fromStdin ? await readStdin(stdin) : await readTextFile(path, "records");
+	const records = [];
+	for (const [offset, line] of text.split("\n").entries()) {
+		if (line.trim() === "") continue;
+		try {
+			records.push(recordSchema.parse(JSON.parse(line)));
+		} catch (cause) {
+			throw new InputError(`${source} line ${offset + 1} is not a valid Record: ${reason(cause)}`, { cause });
+		}
+	}
+	return records;
+}
+async function readStdin(stream) {
+	const decoder = new TextDecoder();
+	let text = "";
+	for await (const chunk of stream) text += chunk instanceof Uint8Array ? decoder.decode(chunk, { stream: true }) : chunk;
+	return text + decoder.decode();
+}
+const issueSchema = z.object({
+	path: z.array(z.union([
+		z.string(),
+		z.number(),
+		z.symbol()
+	])),
+	message: z.string()
+});
+const issuesHolder = z.object({ issues: z.array(z.unknown()) });
+/** Zod's issues by shape, not by class, so a second copy of Zod still reads. */
+function issuesOf(cause) {
+	const holder = issuesHolder.safeParse(cause);
+	if (!holder.success) return void 0;
+	const issues = holder.data.issues.flatMap((candidate) => {
+		const issue = issueSchema.safeParse(candidate);
+		return issue.success ? [issue.data] : [];
+	});
+	return issues.length === 0 ? void 0 : issues;
+}
+function reason(cause) {
+	const issues = issuesOf(cause);
+	if (issues) return firstIssue(issues);
+	if (cause instanceof Error) {
+		const nested = issuesOf(cause.cause);
+		return nested ? `${cause.message}: ${firstIssue(nested)}` : cause.message;
+	}
+	return String(cause);
+}
+/** The first issue with its path, and how many stand behind it. */
+function firstIssue(issues) {
+	const first = issues[0];
+	if (!first) return "invalid";
+	return `${first.path.length === 0 ? "" : `${first.path.join(".")}: `}${first.message}${andMore(issues.length)}`;
+}
+/** The tail every "here is the first of them" sentence in this file ends with. */
+function andMore(count) {
+	return count === 1 ? "" : ` (and ${count - 1} more)`;
+}
+//#endregion
+//#region src/options.ts
+const API_KEY_ENV = "TYPESAFE_API_KEY";
+/** Each command hands `parseArgs` only its own flags, so a foreign one is an unknown option. */
+const TEST_FLAGS = {
+	"max-in-flight": { type: "string" },
+	"min-accuracy": { type: "string" },
+	json: { type: "boolean" },
+	quiet: { type: "boolean" }
+};
+const LABEL_FLAGS = {
+	"max-in-flight": { type: "string" },
+	quiet: { type: "boolean" },
+	rules: { type: "string" }
+};
+function parseTestArgs(args) {
+	const { values, positionals } = parseWith(args, TEST_FLAGS);
+	return {
+		positionals,
+		options: {
+			maxInFlight: gateWidth(values["max-in-flight"]),
+			minAccuracy: ratio$1(values["min-accuracy"]),
+			json: values.json === true,
+			quiet: values.quiet === true
+		}
+	};
+}
+function parseLabelArgs(args) {
+	const { values, positionals } = parseWith(args, LABEL_FLAGS);
+	return {
+		positionals,
+		options: {
+			maxInFlight: gateWidth(values["max-in-flight"]),
+			quiet: values.quiet === true,
+			rules: values.rules ?? null
+		}
+	};
+}
+function parseWith(args, flags) {
+	try {
+		return parseArgs({
+			args: [...args],
+			options: flags,
+			allowPositionals: true,
+			strict: true
+		});
+	} catch (cause) {
+		throw new UsageError(firstSentence(cause), { cause });
+	}
+}
+/** The key is read here and nowhere else, so it never reaches argv, usage or a log line. */
+function requireApiKey(env) {
+	const key = env[API_KEY_ENV];
+	if (key === void 0 || key.trim() === "") throw new UsageError(`${API_KEY_ENV} is not set`);
+}
+function gateWidth(raw) {
+	if (raw === void 0) return DEFAULT_MAX_IN_FLIGHT;
+	const value = parseNumber(raw);
+	if (value === void 0 || !Number.isInteger(value) || value < 1) throw new UsageError(`--max-in-flight takes an integer of 1 or more, not ${JSON.stringify(raw)}`);
+	return value;
+}
+function ratio$1(raw) {
+	if (raw === void 0) return null;
+	const value = parseNumber(raw);
+	if (value === void 0 || value < 0 || value > 1) throw new UsageError(`--min-accuracy takes a ratio from 0 to 1, not ${JSON.stringify(raw)}`);
+	return value;
+}
+function parseNumber(raw) {
+	if (raw.trim() === "") return void 0;
+	const value = Number(raw);
+	return Number.isFinite(value) ? value : void 0;
+}
+function firstSentence(cause) {
+	const message = cause instanceof Error ? cause.message : String(cause);
+	return message.split(". ")[0] ?? message;
+}
+//#endregion
+//#region src/report.ts
+const NA = "n/a";
+/** Wide enough for `0.00` plus the gap before the note beside it. */
+const RATIO_COLUMN = 6;
+function watchDrift(recipeModel, stderr) {
+	let message = null;
+	return {
+		note: (decisionModel) => {
+			if (message !== null || decisionModel === recipeModel) return;
+			message = `model drift: the Recipe asks for ${recipeModel}, the Decisions came back from ${decisionModel}`;
+			writeLine(stderr, `siftline: ${message}`);
+		},
+		get message() {
+			return message;
+		}
+	};
+}
+/** One line per result, or one per miss. `order` is the Recipe's Question order. */
+function progressLines(result, order) {
+	if (result.mismatches.length === 0) return [`ok ${result.id}`];
+	return inOrder(result.mismatches, order).map((miss) => `miss ${result.id} ${describeMismatch(miss)}`);
+}
+function renderReport(report, order) {
+	const rows = Object.entries(report.questions).map(([question, tally]) => ({
+		question,
+		counts: tally.asserted === 0 ? NA : `${tally.matched}/${tally.asserted}`,
+		accuracy: ratio(tally.accuracy)
+	}));
+	const labels = Math.max(...rows.map((row) => row.question.length), 8, 6) + 3;
+	const counts = Math.max(...rows.map((row) => row.counts.length), 3) + 3;
+	const lines = [
+		`${report.recipe.name} v${report.recipe.version} · ${report.model === "" ? NA : report.model}`,
+		"",
+		...rows.map((row) => `${row.question.padEnd(labels)}${row.counts.padEnd(counts)}${row.accuracy}`),
+		"",
+		`${"accuracy".padEnd(labels)}${ratio(report.accuracy).padEnd(RATIO_COLUMN)}(lowest question)`,
+		`${"unsure".padEnd(labels)}${unsure(report)} of ${report.fixtures.length} would go to Review`
+	];
+	const misses = report.fixtures.flatMap((result) => inOrder(result.mismatches, order).map((miss) => `${result.id}  ${describeMismatch(miss)}`));
+	if (misses.length > 0) lines.push("", ...misses);
+	return lines.join("\n");
+}
+function unsure(report) {
+	return report.fixtures.filter((result) => result.review).length;
+}
+function ratio(value) {
+	return value === null ? NA : value.toFixed(2);
+}
+function describeMismatch(miss) {
+	return `${miss.question}: expected ${show(miss.expected)}, got ${show(miss.actual)}`;
+}
+function show(value) {
+	return value === void 0 ? "nothing" : String(value);
+}
+function inOrder(mismatches, order) {
+	return mismatches.toSorted((a, b) => order.indexOf(a.question) - order.indexOf(b.question));
+}
+//#endregion
+//#region src/label.ts
+async function runLabel(args, deps) {
+	const { positionals, options } = parseLabelArgs(args);
+	const [recipePath, recordsPath] = positionals;
+	if (recipePath === void 0) throw new UsageError("label needs a recipe");
+	if (positionals.length > 2) throw new UsageError(`label takes at most two positionals, not ${positionals.length}`);
+	const recipe = await readRecipeFile(recipePath);
+	const rules = options.rules === null ? null : await readRulesFile(options.rules, recipe);
+	return await label(await readRecords(recordsPath, deps.stdin), recipe, rules, deps, options);
+}
+async function label(records, recipe, rules, deps, options) {
+	const { maxInFlight } = options;
+	const judge = createJudge({
+		client: deps.client,
+		retry: "patient",
+		maxInFlight
+	});
+	const progress = createProgress(deps.stderr, records.length, options.quiet);
+	const drift = watchDrift(recipe.model, deps.stderr);
+	const buffered = /* @__PURE__ */ new Map();
+	let written = 0;
+	const flush = () => {
+		while (buffered.has(written)) {
+			const line = buffered.get(written) ?? null;
+			buffered.delete(written);
+			written += 1;
+			if (line !== null) writeLine(deps.stdout, line);
+		}
+	};
+	const controller = new AbortController();
+	const signal = deps.signal ? AbortSignal.any([deps.signal, controller.signal]) : controller.signal;
+	let fatal;
+	let failed = false;
+	let taken = 0;
+	let done = 0;
+	const worker = async () => {
+		while (fatal === void 0) {
+			const index = taken;
+			const record = records[index];
+			if (record === void 0) return;
+			taken += 1;
+			try {
+				const decision = await judge(record, recipe, { signal });
+				drift.note(decision.model);
+				buffered.set(index, serializeDecision(rules === null ? decision : routeDecision(decision, rules)));
+			} catch (error) {
+				if (!(error instanceof JudgeError)) {
+					fatal ??= error;
+					controller.abort(error);
+					return;
+				}
+				failed = true;
+				writeLine(deps.stderr, `${record.id}: ${sentence(error)}`);
+				buffered.set(index, null);
+			}
+			done += 1;
+			progress.tick(done);
+			flush();
+		}
+	};
+	const width = Math.min(maxInFlight, records.length);
+	await Promise.all(Array.from({ length: width }, () => worker()));
+	progress.finish();
+	if (fatal !== void 0) throw fatal;
+	return failed ? 1 : 0;
+}
+const REASONS = {
+	max_tokens_exceeded: "state over the token budget",
+	api_usage_error: "the API refused the request",
+	network: "the call never reached the API",
+	timeout: "the call timed out"
+};
+function sentence(error) {
+	if (error.reason === "unknown") return error.message;
+	if (error.reason === "invalid_answers") return `the answers did not fit the Recipe: ${error.message}`;
+	return REASONS[error.reason];
+}
+/** One line per this many Records where the counter cannot be rewritten in place. */
+const PROGRESS_EVERY = 50;
+const SILENT = {
+	tick: () => void 0,
+	finish: () => void 0
+};
+function createProgress(stream, total, quiet) {
+	if (quiet || total === 0) return SILENT;
+	if (stream.isTTY === true) return {
+		tick: (done) => {
+			stream.write(`\r${done}/${total}`);
+		},
+		finish: () => {
+			stream.write("\n");
+		}
+	};
+	return {
+		tick: (done) => {
+			if (done % PROGRESS_EVERY === 0) writeLine(stream, `${done}/${total}`);
+		},
+		finish: () => void 0
+	};
+}
+//#endregion
+//#region src/test.ts
+async function runTest(args, deps) {
+	const { positionals, options } = parseTestArgs(args);
+	const [recipePath, fixturesPath] = positionals;
+	if (recipePath === void 0 || fixturesPath === void 0) throw new UsageError("test needs a recipe and a fixtures file");
+	if (positionals.length > 2) throw new UsageError(`test takes two positionals, not ${positionals.length}`);
+	const recipe = await readRecipeFile(recipePath);
+	const fixtures = await readFixturesFile(fixturesPath, recipe);
+	const order = Object.keys(recipe.questions);
+	const judge = createJudge({
+		client: deps.client,
+		retry: "patient",
+		maxInFlight: options.maxInFlight
+	});
+	const drift = watchDrift(recipe.model, deps.stderr);
+	const report = await testRecipe(judge, recipe, fixtures, {
+		signal: deps.signal,
+		onResult: (result) => {
+			drift.note(result.decision.model);
+			if (options.quiet) return;
+			for (const line of progressLines(result, order)) writeLine(deps.stderr, line);
+		}
+	});
+	if (options.json) writeLine(deps.stdout, JSON.stringify({
+		...report,
+		drift: drift.message
+	}, null, 2));
+	else writeLine(deps.stdout, renderReport(report, order));
+	const floor = options.minAccuracy;
+	if (floor === null) return 0;
+	if (report.accuracy === null) {
+		writeLine(deps.stderr, `siftline: no Question was asserted, so there is no accuracy to meet --min-accuracy ${floor}`);
+		return 1;
+	}
+	if (report.accuracy < floor) {
+		writeLine(deps.stderr, `siftline: accuracy ${report.accuracy.toFixed(2)} is below --min-accuracy ${floor}`);
+		return 1;
+	}
+	return 0;
+}
+//#endregion
+//#region src/usage.ts
+/** The published version of `@siftline/cli`, baked in at build time. */
+const VERSION$1 = "0.1.1";
+const USAGE = [
+	`siftline ${VERSION$1} (engine ${VERSION})`,
+	"",
+	"Usage",
+	"  siftline test  <recipe.json> <fixtures.jsonl> [--max-in-flight <n>] [--min-accuracy <ratio>] [--json] [--quiet]",
+	"  siftline label <recipe.json> [records.jsonl | -] [--rules <rules.json>] [--max-in-flight <n>] [--quiet]",
+	"",
+	"Options",
+	"  --max-in-flight <n>     Records judged at once (default 8)",
+	"  --min-accuracy <ratio>  test: exit 1 when the lowest question accuracy is below this",
+	"  --json                  test: print the report as JSON",
+	"  --rules <rules.json>    label: select an Action per Decision with these Rules",
+	"  --quiet                 Silence progress (never warnings or errors)",
+	"  --help                  Print this help and exit",
+	"  --version               Print the version and exit",
+	"",
+	"Environment",
+	"  TYPESAFE_API_KEY        Required. Read from the environment only."
+].join("\n");
+//#endregion
+//#region src/index.ts
+/**
+* The library door. Every command runs through it, so a test drives the whole CLI with an
+* injected client and string streams and asserts on the exit code and what was written.
+*/
+async function run(argv, deps) {
+	try {
+		if (argv.includes("--help")) {
+			writeLine(deps.stdout, USAGE);
+			return 0;
+		}
+		if (argv.includes("--version")) {
+			writeLine(deps.stdout, VERSION$1);
+			return 0;
+		}
+		const [command, ...rest] = argv;
+		if (command === void 0) throw new UsageError("no command given");
+		if (command !== "test" && command !== "label") throw new UsageError(`unknown command: ${command}`);
+		requireApiKey(deps.env);
+		return command === "label" ? await runLabel(rest, deps) : await runTest(rest, deps);
+	} catch (cause) {
+		return exitFor(cause, deps);
+	}
+}
+/** Every failure's exit code and its one stderr line. */
+function exitFor(cause, deps) {
+	if (deps.signal?.aborted) {
+		writeLine(deps.stderr, "siftline: interrupted");
+		return 130;
+	}
+	if (cause instanceof UsageError) {
+		writeLine(deps.stderr, `siftline: ${cause.message}\n\n${USAGE}`);
+		return 2;
+	}
+	if (cause instanceof InputError) {
+		writeLine(deps.stderr, `siftline: ${cause.message}`);
+		return 2;
+	}
+	if (cause instanceof SiftlineError) {
+		writeLine(deps.stderr, `siftline: ${cause.message}`);
+		return cause.code === "fixture_invalid" ? 2 : 1;
+	}
+	writeLine(deps.stderr, `siftline: ${cause instanceof Error ? cause.message : String(cause)}`);
+	return 1;
+}
+//#endregion
+export { API_KEY_ENV as i, USAGE as n, VERSION$1 as r, run as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@siftline/cli",
-  "version": "0.0.2",
+  "version": "0.1.1",
   "description": "The Siftline command line: measure a recipe against its fixtures, then label for real.",
   "keywords": [
     "classification",
@@ -45,7 +45,9 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@siftline/core": "^0.0.3"
+    "@siftline/core": "^0.1.1",
+    "@typesafe-ai/sdk": "0.6.0",
+    "zod": "4.6.5"
   },
   "devDependencies": {
     "@arethetypeswrong/core": "0.18.5",

package/dist/src-DYu5d4UT.mjs

@@ -1,51 +0,0 @@
-import { VERSION } from "@siftline/core";
-//#endregion
-//#region src/index.ts
-/**
-* The published version of `@siftline/cli`, baked in at build time.
-*
-* Changesets bumps `package.json`; this constant follows it without a second edit.
-*/
-const VERSION$1 = "0.0.2";
-/**
-* The usage block. `test` and `label` are named before they exist so that the bin
-* wiring is proven — and so that `siftline --help` never lies about what it does.
-*/
-const USAGE = [
-	`siftline ${VERSION$1} (engine ${VERSION})`,
-	"",
-	"Usage",
-	"  siftline <command> [options]",
-	"",
-	"Commands",
-	"  test     Measure a recipe against its fixtures (not yet implemented)",
-	"  label    Label inputs with a recipe (not yet implemented)",
-	"",
-	"Options",
-	"  --help     Print this help and exit",
-	"  --version  Print the version and exit"
-].join("\n");
-/**
-* Interpret command line arguments. Pure on purpose: the bin is the only place that
-* touches the process, so the behaviour stays testable without one.
-*/
-function run(argv) {
-	const [first, ...rest] = argv;
-	if (rest.length === 0 && first === "--version") return {
-		code: 0,
-		stdout: `${VERSION$1}\n`,
-		stderr: ""
-	};
-	if (rest.length === 0 && first === "--help") return {
-		code: 0,
-		stdout: `${USAGE}\n`,
-		stderr: ""
-	};
-	return {
-		code: 1,
-		stdout: "",
-		stderr: `siftline: ${first === void 0 ? "no command given" : `unknown command: ${argv.join(" ")}`}\n\n${USAGE}\n`
-	};
-}
-//#endregion
-export { VERSION$1 as n, run as r, USAGE as t };