yamlite 0.0.0-stage → 0.35.0

package/dist/browser/sqlite.mjs

@@ -0,0 +1,219 @@
+import sqlite3InitModule from "@sqlite.org/sqlite-wasm";
+//#region src/browser/sqlite.ts
+const sqlite3 = await sqlite3InitModule();
+const opfs = typeof globalThis.FileSystemHandle !== "undefined" ? await sqlite3.installOpfsSAHPoolVfs({ name: "yamlite" }) : null;
+let VFS = opfs?.vfsName;
+function registerVfs(name) {
+	VFS = name;
+}
+const { capi, oo1 } = sqlite3;
+const constants = Object.fromEntries(Object.entries(capi).filter(([k, v]) => k.startsWith("SQLITE_") && typeof v === "number"));
+var SqliteError = class extends Error {
+	errcode;
+	errstr;
+	code = "ERR_SQLITE_ERROR";
+	constructor(message, errcode, errstr) {
+		super(message);
+		this.errcode = errcode;
+		this.errstr = errstr;
+	}
+};
+function sqliteError(db, e) {
+	if (e instanceof SqliteError || !(e instanceof Error) || !("resultCode" in e)) return e;
+	const ptr = db.pointer;
+	const code = ptr ? capi.sqlite3_extended_errcode(ptr) : Number(e.resultCode);
+	return new SqliteError(ptr ? capi.sqlite3_errmsg(ptr) : e.message, code, capi.sqlite3_errstr(code));
+}
+const isNamed = (v) => typeof v === "object" && v !== null && !(v instanceof Uint8Array) && !ArrayBuffer.isView(v);
+const finalizer = new FinalizationRegistry((fn) => fn());
+function finalize(stmt) {
+	try {
+		if (stmt.pointer) stmt.finalize();
+	} catch {}
+}
+const finalized = () => Object.assign(/* @__PURE__ */ new Error("statement has been finalized"), { code: "ERR_INVALID_STATE" });
+var StatementSync = class {
+	db;
+	stmt;
+	bigInts = false;
+	arrays = false;
+	constructor(db, stmt, open) {
+		this.db = db;
+		this.stmt = stmt;
+		open.add(stmt);
+		finalizer.register(this, () => {
+			finalize(stmt);
+			open.delete(stmt);
+		});
+	}
+	setReadBigInts(on) {
+		this.bigInts = on;
+	}
+	setReturnArrays(on) {
+		this.arrays = on;
+	}
+	columns() {
+		const p = this.stmt.pointer;
+		if (!p) throw finalized();
+		const n = capi.sqlite3_column_count(p);
+		return Array.from({ length: n }, (_, i) => Object.assign(Object.create(null), {
+			column: null,
+			database: null,
+			name: capi.sqlite3_column_name(p, i),
+			table: null,
+			type: capi.sqlite3_column_decltype(p, i) ?? null
+		}));
+	}
+	bind(params) {
+		const s = this.stmt;
+		const p = s.pointer;
+		if (!p) throw finalized();
+		s.reset();
+		s.clearBindings();
+		const count = capi.sqlite3_bind_parameter_count(p);
+		let named;
+		let rest = params;
+		if (isNamed(params[0])) {
+			named = params[0];
+			rest = params.slice(1);
+		}
+		let next = 0;
+		for (let i = 1; i <= count; i++) {
+			const name = capi.sqlite3_bind_parameter_name(p, i);
+			let v;
+			if (name && named) v = name in named ? named[name] : named[name.slice(1)];
+			else if (!name || /^\?\d*$/.test(name)) v = rest[name && name.length > 1 ? Number(name.slice(1)) - 1 : next++];
+			else continue;
+			if (v === void 0) continue;
+			if (v === null) capi.sqlite3_bind_null(p, i);
+			else if (typeof v === "number") capi.sqlite3_bind_double(p, i, v);
+			else if (typeof v === "bigint") capi.sqlite3_bind_int64(p, i, v);
+			else if (typeof v === "string" || v instanceof Uint8Array) s.bind(i, v);
+			else throw new TypeError(`Provided value cannot be bound to SQLite parameter ${i}.`);
+		}
+	}
+	row() {
+		const p = this.stmt.pointer;
+		const n = capi.sqlite3_column_count(p);
+		const values = [];
+		for (let i = 0; i < n; i++) switch (capi.sqlite3_column_type(p, i)) {
+			case capi.SQLITE_INTEGER: {
+				const v = BigInt(capi.sqlite3_column_int64(p, i));
+				if (this.bigInts) values.push(v);
+				else if (v > BigInt(Number.MAX_SAFE_INTEGER) || v < BigInt(Number.MIN_SAFE_INTEGER)) {
+					const e = /* @__PURE__ */ new RangeError(`Value is too large to be represented as a JavaScript number: ${v}`);
+					throw Object.assign(e, { code: "ERR_OUT_OF_RANGE" });
+				} else values.push(Number(v));
+				break;
+			}
+			case capi.SQLITE_FLOAT:
+				values.push(capi.sqlite3_column_double(p, i));
+				break;
+			case capi.SQLITE_TEXT:
+				values.push(capi.sqlite3_column_text(p, i));
+				break;
+			case capi.SQLITE_BLOB:
+				values.push(this.stmt.get(i, capi.SQLITE_BLOB));
+				break;
+			default: values.push(null);
+		}
+		if (this.arrays) return values;
+		const row = Object.create(null);
+		for (let i = 0; i < n; i++) row[capi.sqlite3_column_name(p, i)] = values[i];
+		return row;
+	}
+	step() {
+		try {
+			return this.stmt.step();
+		} catch (e) {
+			const err = sqliteError(this.db, e);
+			try {
+				this.stmt.reset();
+			} catch {}
+			throw err;
+		}
+	}
+	all(...params) {
+		this.bind(params);
+		const rows = [];
+		while (this.step()) rows.push(this.row());
+		this.stmt.reset();
+		return rows;
+	}
+	get(...params) {
+		this.bind(params);
+		const row = this.step() ? this.row() : void 0;
+		this.stmt.reset();
+		return row;
+	}
+	*iterate(...params) {
+		this.bind(params);
+		try {
+			while (this.step()) yield this.row();
+		} finally {
+			this.stmt.reset();
+		}
+	}
+	run(...params) {
+		this.bind(params);
+		while (this.step());
+		this.stmt.reset();
+		const changes = capi.sqlite3_changes(this.db.pointer);
+		const last = BigInt(capi.sqlite3_last_insert_rowid(this.db.pointer));
+		return this.bigInts ? {
+			changes: BigInt(changes),
+			lastInsertRowid: last
+		} : {
+			changes: Number(changes),
+			lastInsertRowid: Number(last)
+		};
+	}
+};
+var DatabaseSync = class {
+	db;
+	stmts = /* @__PURE__ */ new Set();
+	constructor(path, opts = {}) {
+		try {
+			this.db = new oo1.DB({
+				filename: path,
+				flags: opts.readOnly ? "r" : "c",
+				...VFS && path !== ":memory:" ? { vfs: VFS } : {}
+			});
+		} catch (e) {
+			throw new SqliteError(e instanceof Error ? e.message : String(e), capi.SQLITE_CANTOPEN, "unable to open database file");
+		}
+		capi.sqlite3_extended_result_codes(this.db.pointer, 1);
+	}
+	get isOpen() {
+		return !!this.db.pointer;
+	}
+	get isTransaction() {
+		return capi.sqlite3_get_autocommit(this.db.pointer) === 0;
+	}
+	exec(sql) {
+		try {
+			this.db.exec(sql);
+		} catch (e) {
+			throw sqliteError(this.db, e);
+		}
+	}
+	prepare(sql) {
+		try {
+			return new StatementSync(this.db, this.db.prepare(sql), this.stmts);
+		} catch (e) {
+			throw sqliteError(this.db, e);
+		}
+	}
+	setAuthorizer(fn) {
+		const cb = fn ? (_p, action, ...args) => fn(action, ...args.map((a) => a === 0 ? null : a)) : 0;
+		capi.sqlite3_set_authorizer(this.db.pointer, cb, 0);
+	}
+	close() {
+		if (!this.db.pointer) throw Object.assign(/* @__PURE__ */ new Error("database is not open"), { code: "ERR_INVALID_STATE" });
+		for (const s of this.stmts) finalize(s);
+		this.stmts.clear();
+		this.db.close();
+	}
+};
+//#endregion
+export { DatabaseSync, StatementSync, constants, opfs, registerVfs, sqlite3 };

package/dist/browser/unavailable.d.mts

@@ -0,0 +1,15 @@
+//#region src/browser/unavailable.d.ts
+export declare const spawn: () => never;
+export declare const pipeline: () => never;
+export declare class Readable {}
+export declare class Writable {}
+export declare const fileURLToPath: (u: string | URL) => string;
+export declare const watch: () => {
+  on: () => /*elided*/ any;
+  close: () => Promise<void>;
+  add: () => /*elided*/ any;
+  unwatch: () => /*elided*/ any;
+};
+declare const _default: {};
+//#endregion
+export { _default as default };

package/dist/browser/unavailable.mjs

@@ -0,0 +1,21 @@
+//#region src/browser/unavailable.ts
+const no = (what) => () => {
+	throw new Error(`${what} is not available in the browser build`);
+};
+const spawn = no("child_process.spawn");
+const pipeline = no("stream.pipeline");
+var Readable = class {};
+var Writable = class {};
+const fileURLToPath = (u) => new URL(u).pathname;
+const watch = () => {
+	const w = {
+		on: () => w,
+		close: async () => {},
+		add: () => w,
+		unwatch: () => w
+	};
+	return w;
+};
+var unavailable_default = {};
+//#endregion
+export { Readable, Writable, unavailable_default as default, fileURLToPath, pipeline, spawn, watch };

package/dist/cli.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/cli.mjs

@@ -0,0 +1,433 @@
+#!/usr/bin/env node
+import { I as isLoopback, L as loopbackHosts, P as createHandler, R as check, a as query, c as exportSite, i as formatTable, n as formatCsv, o as generateConfig, r as formatJson, s as init, t as open } from "./src-DKu7thkC.mjs";
+import { n as guide, r as envKeys, t as createWorkspace } from "./workspace-BHg_GGkH.mjs";
+import { createRequire } from "node:module";
+import { relative, resolve } from "node:path";
+import { homedir } from "node:os";
+import { randomBytes } from "node:crypto";
+import { fileURLToPath } from "node:url";
+import { spawn } from "node:child_process";
+import { Command } from "commander";
+import { styleText } from "node:util";
+import { createServer } from "node:http";
+//#region src/format.ts
+const painter = (stream) => (style, text) => styleText(style, text, { stream });
+const MIN_SUMMARY_WIDTH = 38;
+const WATCH_LABEL_WIDTH = 10;
+const plural = (n, word, many = `${word}s`) => `${n} ${n === 1 ? word : many}`;
+function displayPath(path, home = homedir()) {
+	return path === home || path.startsWith(`${home}/`) ? `~${path.slice(home.length)}` : path;
+}
+const changeCount = (r) => r.toDb + r.toFile + r.deletedDb + r.deletedFile;
+function schemaCounts(schema) {
+	const columns = schema.filter((c) => c.op === "alterColumn" || c.op === "dropColumn").length;
+	const views = schema.filter((c) => c.op === "createView" || c.op === "dropView").length;
+	const indexes = schema.length - columns - views;
+	return [
+		columns > 0 ? plural(columns, "column change") : "",
+		indexes > 0 ? plural(indexes, "index change") : "",
+		views > 0 ? plural(views, "view change") : ""
+	].filter(Boolean);
+}
+function schemaDetail(c, paint, mode) {
+	if (c.op === "dropColumn") return `${paint("red", "−")} column ${c.name} ${paint("dim", "(removed from yamlite.yaml)")}`;
+	if (c.op === "alterColumn") {
+		const note = mode === "status" ? "table will be rebuilt" : "table rebuilt";
+		return `${paint("cyan", "↻")} column ${c.name} ${c.definition} ${paint("dim", `(${note})`)}`;
+	}
+	if (c.op === "createView") return `${paint("green", "+")} view ${c.definition}`;
+	if (c.op === "dropView") return `${paint("red", "−")} view ${c.definition}`;
+	return c.op === "createIndex" ? `${paint("green", "+")} index ${c.definition}` : `${paint("red", "−")} index ${c.definition}`;
+}
+function summary(r) {
+	const parts = [
+		r.toDb > 0 ? `${r.toDb} → db` : "",
+		r.toFile > 0 ? `${r.toFile} → file` : "",
+		r.deletedDb > 0 ? `${plural(r.deletedDb, "row")} deleted` : "",
+		r.deletedFile > 0 ? `${plural(r.deletedFile, "file")} deleted` : "",
+		r.conflicts.length > 0 ? plural(r.conflicts.length, "conflict") : "",
+		...schemaCounts(r.schema),
+		r.registered.length > 0 ? plural(r.registered.length, "new column") : ""
+	].filter(Boolean);
+	return parts.length > 0 ? parts.join(" · ") : "in sync";
+}
+function resolution(c, root) {
+	const loser = c.winner === "db" ? "file" : "db";
+	const saved = c.savedTo ? ` · ${loser} version saved to ${relative(root, c.savedTo)}` : "";
+	return `kept ${c.winner}${saved}`;
+}
+function conflictText(c, root, done) {
+	return `changed on both sides · ${done ? resolution(c, root) : `${c.winner} will win`}`;
+}
+function report(results, { mode, root, paint, elapsedMs = 0 }) {
+	const nameWidth = Math.max(0, ...results.map((r) => r.table.length));
+	const summaryWidth = Math.max(MIN_SUMMARY_WIDTH, ...results.map((r) => summary(r).length + 2));
+	const indent = " ".repeat(4 + nameWidth + 3);
+	const lines = [`${paint("bold", "YAMLite")} ${paint("dim", `· ${displayPath(root)}`)}`, ""];
+	for (const r of results) {
+		const name = r.table.padEnd(nameWidth);
+		if (!r.ok) {
+			lines.push(`  ${paint("red", "✗")} ${name}   ${paint("red", r.error ?? "failed")}`);
+			continue;
+		}
+		const icon = mode === "status" && (changeCount(r) > 0 || r.schema.length > 0 || r.registered.length > 0) ? paint("yellow", "●") : paint("green", "✓");
+		const records = paint("dim", plural(r.records, "record"));
+		lines.push(`  ${icon} ${name}   ${summary(r).padEnd(summaryWidth)}${records}`);
+		for (const c of r.schema) lines.push(`${indent}${schemaDetail(c, paint, mode)}`);
+		const note = mode === "status" ? "will be added to yamlite.yaml" : "added to yamlite.yaml";
+		for (const c of r.registered) lines.push(`${indent}${paint("green", "+")} column ${c.column} ${c.type} ${paint("dim", `(${note})`)}`);
+		for (const w of r.warnings) lines.push(`${indent}${paint("yellow", "!")} ${w}`);
+		for (const c of r.conflicts) lines.push(`${indent}${paint("yellow", "⚠")} ${c.key}: ${conflictText(c, root, mode === "sync")}`);
+	}
+	const changes = results.reduce((n, r) => n + changeCount(r), 0);
+	const newColumns = results.reduce((n, r) => n + r.registered.length, 0);
+	const work = [
+		changes > 0 ? plural(changes, "change") : "",
+		...schemaCounts(results.flatMap((r) => r.schema)),
+		newColumns > 0 ? plural(newColumns, "new column") : ""
+	].filter(Boolean);
+	const conflicts = results.reduce((n, r) => n + r.conflicts.length, 0);
+	const errors = results.filter((r) => !r.ok).length;
+	const extras = [conflicts > 0 ? plural(conflicts, "conflict") : "", errors > 0 ? paint("red", plural(errors, "error")) : ""].filter(Boolean);
+	let footer;
+	if (mode === "status") {
+		if (work.length === 0 && errors === 0) footer = paint("green", "Everything is in sync");
+		else {
+			const head = work.length > 0 ? `${work.join(" · ")} pending` : "no changes pending";
+			const hint = work.length > 0 ? [paint("dim", "run yamlite sync to apply")] : [];
+			footer = [
+				head,
+				...extras,
+				...hint
+			].join(" · ");
+		}
+	} else footer = [
+		`Synced ${plural(results.length, "table")} in ${Math.round(elapsedMs)}ms`,
+		...work.length > 0 ? work : ["no changes"],
+		...extras
+	].join(" · ");
+	lines.push("", `  ${footer}`);
+	return lines.join("\n");
+}
+function checkReport(result, { root, paint }) {
+	const nameWidth = Math.max(0, ...result.tables.map((t) => t.table.length));
+	const indent = " ".repeat(4 + nameWidth + 3);
+	const lines = [`${paint("bold", "YAMLite")} ${paint("dim", `· ${displayPath(root)}`)}`, ""];
+	const unlisted = new Set(result.unregisteredTables);
+	let problems = 0;
+	for (const t of result.tables) {
+		const name = t.table.padEnd(nameWidth);
+		if (!t.ok) {
+			problems++;
+			lines.push(`  ${paint("red", "✗")} ${name}   ${paint("red", t.error ?? "failed")}`);
+			continue;
+		}
+		const details = [
+			...unlisted.has(t.table) ? [`${paint("yellow", "+")} table ${paint("dim", "(not in yamlite.yaml)")}`] : [],
+			...t.unregistered.map((c) => `${paint("yellow", "+")} column ${c.column} ${c.type} ${paint("dim", "(not in yamlite.yaml)")}`),
+			...t.warnings.map((w) => `${paint("yellow", "!")} ${w}`)
+		];
+		problems += details.length;
+		lines.push(`  ${details.length > 0 ? paint("red", "✗") : paint("green", "✓")} ${t.table}`);
+		for (const d of details) lines.push(`${indent}${d}`);
+	}
+	lines.push("", problems === 0 ? paint("green", "✓ no problems") : paint("red", `✗ ${plural(problems, "problem")}`));
+	return lines.join("\n");
+}
+function watchHeader(tables, root, paint) {
+	const names = tables.length > 0 ? tables.join(", ") : "(no tables)";
+	return `${paint("bold", "YAMLite")} · watching ${names} in ${displayPath(root)} ${paint("dim", "· Ctrl-C to stop")}`;
+}
+const clock = (now) => [
+	now.getHours(),
+	now.getMinutes(),
+	now.getSeconds()
+].map((n) => String(n).padStart(2, "0")).join(":");
+function reloadLine(tables, now, paint) {
+	const names = tables.length > 0 ? tables.join(", ") : "(no tables)";
+	return `  ${paint("dim", clock(now))}  ${paint("cyan", "↻ reloaded")} config · watching ${names}`;
+}
+const OP_LABEL = {
+	toDb: ["cyan", "→ db"],
+	toFile: ["cyan", "→ file"],
+	deleteDb: ["red", "− row"],
+	deleteFile: ["red", "− file"]
+};
+function watchEvents(r, { root, now, paint, quiet, nameWidth = 0 }) {
+	const prefix = `  ${paint("dim", clock(now))}  ${r.table.padEnd(nameWidth)}  `;
+	const line = (style, label, text) => `${prefix}${paint(style, label.padEnd(WATCH_LABEL_WIDTH))}  ${text}`;
+	if (!r.ok) return [line("red", "✗ error", r.error ?? "failed")];
+	const lines = [];
+	if (!quiet) {
+		for (const c of r.changes) lines.push(line(OP_LABEL[c.op][0], OP_LABEL[c.op][1], c.key));
+		for (const c of r.schema) if (c.op === "alterColumn") lines.push(line("cyan", "↻ column", `${c.name} ${c.definition}`));
+		else if (c.op === "dropColumn") lines.push(line("red", "− column", c.name));
+		else if (c.op === "createIndex") lines.push(line("green", "+ index", c.definition));
+		else if (c.op === "createView") lines.push(line("green", "+ view", c.definition));
+		else if (c.op === "dropView") lines.push(line("red", "− view", c.definition));
+		else lines.push(line("red", "− index", c.definition));
+		for (const c of r.registered) lines.push(line("green", "+ column", `${c.column} ${c.type}`));
+	}
+	for (const c of r.conflicts) lines.push(line("yellow", "⚠ conflict", `${c.key} · ${resolution(c, root)}`));
+	if (!quiet) for (const w of r.warnings) lines.push(line("yellow", "! warning", w));
+	return lines;
+}
+//#endregion
+//#region src/serve/index.ts
+const DEFAULT_UI = fileURLToPath(new URL("./ui/", import.meta.url));
+const urlHostOf = (h) => h.includes(":") ? `[${h}]` : h;
+function listen(server, port, host) {
+	return new Promise((done, fail) => {
+		server.once("error", (e) => {
+			fail(e.code === "EADDRINUSE" ? /* @__PURE__ */ new Error(`port ${port} is already in use; pick another one with --port`) : e);
+		});
+		server.listen(port, host, () => done(server.address().port));
+	});
+}
+async function serve(opts) {
+	const host = opts.host ?? "127.0.0.1";
+	let port = 0;
+	const w = await createWorkspace({
+		root: opts.root,
+		db: opts.db,
+		watch: opts.watch,
+		ai: opts.agent === false ? null : opts.ai ?? {
+			keys: envKeys(process.env),
+			webSearch: opts.webSearch
+		},
+		gh: opts.gh,
+		git: opts.git
+	});
+	try {
+		const token = randomBytes(24).toString("hex");
+		let policy = {
+			token,
+			allowedHosts: /* @__PURE__ */ new Set()
+		};
+		const http = createServer(createHandler(w.router, () => policy, opts.uiDir ?? DEFAULT_UI));
+		port = await listen(http, opts.port ?? 4610, host);
+		policy = {
+			token,
+			allowedHosts: isLoopback(host) ? loopbackHosts(port) : null
+		};
+		let closing;
+		return {
+			url: `http://${urlHostOf(host)}:${port}/?token=${token}`,
+			port,
+			token,
+			context: w.context,
+			close() {
+				closing ??= (async () => {
+					try {
+						http.closeAllConnections();
+						await new Promise((done) => http.close(() => done()));
+					} finally {
+						await w.close();
+					}
+				})();
+				return closing;
+			}
+		};
+	} catch (e) {
+		await w.close();
+		throw e;
+	}
+}
+//#endregion
+//#region src/cli.ts
+const { version } = createRequire(import.meta.url)("../package.json");
+const collect = (value, previous) => [...previous, value];
+const out = painter(process.stdout);
+const err = painter(process.stderr);
+function withRoot(cmd) {
+	return cmd.argument("[root]", "data directory", ".").option("--db <path>", "SQLite database (default: <root>/.yamlite/db.sqlite)");
+}
+const program = new Command().name("yamlite").description("Sync YAML files and SQLite in both directions").version(version);
+withRoot(program.command("init").description("create yamlite.yaml from the YAML files and the existing database")).option("--force", "overwrite an existing yamlite.yaml").option("--print", "print the generated yamlite.yaml instead of writing it").action((root, o) => {
+	if (o.print) {
+		process.stdout.write(generateConfig({
+			root,
+			db: o.db,
+			force: true
+		}));
+		return;
+	}
+	const result = init({
+		root,
+		db: o.db,
+		force: o.force
+	});
+	const tables = result.tables.length > 0 ? result.tables.join(", ") : "no tables yet";
+	console.log(`${out("green", "✓")} wrote ${displayPath(result.path)} ${out("dim", `· ${tables}`)}`);
+	console.log(`  next: ${out("bold", "yamlite status")} to preview, ${out("bold", "yamlite sync")} to apply`);
+});
+program.command("guide").description("print the guide to writing yamlite.yaml, for people and AI agents").action(() => {
+	process.stdout.write(guide());
+});
+program.command("check").description("check the YAML files against yamlite.yaml without writing anything; exits 1 on any problem").argument("[root]", "data directory", ".").option("--table <name>", "only this table (repeatable)", collect, []).option("--json", "print JSON").action(async (root, o) => {
+	const result = await check({
+		root,
+		tables: o.table
+	});
+	if (o.json) console.log(JSON.stringify(result, null, 2));
+	else console.log(checkReport(result, {
+		root: resolve(root),
+		paint: out
+	}));
+	if (!result.ok) process.exitCode = 1;
+});
+const FORMATS = {
+	table: formatTable,
+	json: formatJson,
+	csv: formatCsv
+};
+program.command("query").description("run one read-only SQL statement against the YAML files (or --db) and print the rows").argument("<sql>", "the statement").argument("[root]", "data directory", ".").option("--db <path>", "read this database as it is instead of the YAML files").option("--format <format>", "table, json or csv", "table").option("--limit <n>", "at most this many rows; 0 for no limit", "1000").action(async (sql, root, o) => {
+	if (!Object.hasOwn(FORMATS, o.format)) throw new Error(`unknown format ${o.format}: use table, json or csv`);
+	const format = FORMATS[o.format];
+	const limit = Number(o.limit);
+	if (!Number.isInteger(limit) || limit < 0) throw new Error(`--limit must be a whole number, not ${o.limit}`);
+	const r = await query({
+		root,
+		db: o.db,
+		sql,
+		limit
+	});
+	for (const w of r.warnings) console.error(`${err("yellow", "!")} ${w}`);
+	process.stdout.write(o.format === "csv" ? format(r) : `${format(r)}\n`);
+	if (o.format === "table") console.error(err("dim", `${r.rows.length} ${r.rows.length === 1 ? "row" : "rows"}`));
+	if (r.truncated) console.error(err("yellow", `… truncated at ${limit} rows (use --limit)`));
+});
+withRoot(program.command("status").description("show what sync would change, without writing")).option("--table <name>", "only this table (repeatable)", collect, []).option("--json", "print JSON").action(async (root, o) => {
+	const y = await open({
+		root,
+		db: o.db
+	});
+	try {
+		const results = await y.status({ tables: o.table });
+		if (o.json) console.log(JSON.stringify(results, null, 2));
+		else console.log(report(results, {
+			mode: "status",
+			root: resolve(root),
+			paint: out
+		}));
+	} finally {
+		await y.close();
+	}
+});
+withRoot(program.command("sync").description("sync once")).option("--table <name>", "only this table (repeatable)", collect, []).option("--force", "allow mass deletions").option("--force-convert", "clear values that cannot be converted when a column type changes").option("--json", "print JSON").action(async (root, o) => {
+	const y = await open({
+		root,
+		db: o.db
+	});
+	try {
+		const started = performance.now();
+		const results = await y.sync({
+			tables: o.table,
+			force: o.force,
+			forceConvert: o.forceConvert
+		});
+		const elapsedMs = performance.now() - started;
+		if (o.json) console.log(JSON.stringify(results, null, 2));
+		else console.log(report(results, {
+			mode: "sync",
+			root: resolve(root),
+			paint: out,
+			elapsedMs
+		}));
+		if (results.some((r) => !r.ok)) process.exitCode = 1;
+	} finally {
+		await y.close();
+	}
+});
+withRoot(program.command("watch").description("sync continuously")).option("--quiet", "only print conflicts and errors").action(async (root, o) => {
+	const y = await open({
+		root,
+		db: o.db
+	});
+	const nameWidth = () => Math.max(0, ...y.tables.map((t) => t.name.length));
+	await y.watch({
+		onSync: (r) => {
+			const opts = {
+				root: resolve(root),
+				now: /* @__PURE__ */ new Date(),
+				paint: out,
+				quiet: o.quiet ?? false,
+				nameWidth: nameWidth()
+			};
+			for (const line of watchEvents(r, opts)) console.log(line);
+		},
+		onReload: (tables) => {
+			if (!o.quiet) console.log(reloadLine(tables, /* @__PURE__ */ new Date(), out));
+		},
+		onError: (e, table) => {
+			if (table === void 0) console.error(painter(process.stderr)("red", `error: ${e.message}`));
+		}
+	}).ready;
+	if (!o.quiet) console.log(`${watchHeader(y.tables.map((t) => t.name), resolve(root), out)}\n`);
+	const stop = () => {
+		y.close().then(() => process.exit(0));
+	};
+	process.once("SIGINT", stop);
+	process.once("SIGTERM", stop);
+});
+function openBrowser(url) {
+	const [cmd, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", [
+		"/c",
+		"start",
+		"",
+		url
+	]] : ["xdg-open", [url]];
+	spawn(cmd, args, {
+		stdio: "ignore",
+		detached: true
+	}).on("error", () => {}).unref();
+}
+withRoot(program.command("serve").description("open the web UI and sync continuously")).option("--port <number>", "port to listen on", "4610").option("--host <address>", "address to listen on", "127.0.0.1").option("--open", "open the UI in the browser").option("--no-agent", "do not offer Ask AI in the web UI").option("--web-search", "let Ask AI search the web; each search is billed to the API key").action(async (root, o) => {
+	const port = Number(o.port);
+	if (!Number.isInteger(port) || port < 0 || port > 65535) throw new Error(`invalid port: ${o.port}`);
+	const s = await serve({
+		root,
+		db: o.db,
+		port,
+		host: o.host,
+		agent: o.agent,
+		webSearch: o.webSearch
+	});
+	if (!isLoopback(o.host)) {
+		const askAi = o.agent && Object.keys(envKeys(process.env)).length > 0;
+		console.error(painter(process.stderr)("yellow", `warning: listening on ${o.host}; anyone who can reach it and has the token can read and change the data${askAi ? " and use Ask AI with the API keys from the environment" : ""}`));
+	}
+	console.log(`${out("green", "✓")} YAMLite UI · ${out("bold", s.url)}`);
+	console.log(out("dim", `  watching ${displayPath(resolve(root))} · Ctrl+C to stop`));
+	if (o.open) openBrowser(s.url);
+	let stopping = false;
+	const stop = () => {
+		if (stopping) process.exit(130);
+		stopping = true;
+		s.close().then(() => process.exit(0), (e) => {
+			console.error(`error: ${e instanceof Error ? e.message : String(e)}`);
+			process.exit(1);
+		});
+	};
+	process.on("SIGINT", stop);
+	process.on("SIGTERM", stop);
+});
+program.command("export").description("write the web UI as a read-only static site").argument("[root]", "data directory", ".").option("--out <dir>", "output folder", ".yamlite-export").option("--table <name>", "only this table (repeatable)", collect, []).option("--force", "replace an output folder that is not a previous export").action(async (root, o) => {
+	const r = await exportSite({
+		root,
+		out: o.out,
+		tables: o.table,
+		force: o.force
+	});
+	const count = `${r.tables.length} ${r.tables.length === 1 ? "table" : "tables"}`;
+	console.log(`${out("green", "✓")} exported ${count} to ${displayPath(r.out)}`);
+	for (const [table, warnings] of Object.entries(r.warnings)) for (const w of warnings) console.log(`  ${out("yellow", "!")} ${table}: ${w}`);
+	for (const [page, reason] of Object.entries(r.skippedPages)) console.log(`  ${out("yellow", "!")} page ${page} not exported: ${reason}`);
+	console.log(out("dim", "  serve the folder over HTTP to open it; file:// does not work"));
+});
+program.parseAsync().catch((e) => {
+	console.error(`error: ${e instanceof Error ? e.message : String(e)}`);
+	process.exitCode = 1;
+});
+//#endregion
+export {};