better-supabase 0.3.0 → 0.5.0

package/dist/cli/seed-CUlqWh-8.js

@@ -0,0 +1,98 @@
+import { r as defineCliCommand } from "./command-CK14fP91.js";
+import { r as writeIfChanged, t as display } from "./io-k41_z-jT.js";
+import { r as importExport, s as stdinDatabaseUrl, t as databaseUrl } from "./config-CPVpXP5I.js";
+import { n as withSpinner } from "./prompts-BNcNfAve.js";
+import { t as connect } from "./db-DOBPt660.js";
+import { resolve } from "node:path";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { isSeed } from "better-supabase/testing";
+//#region src/cli/commands/seed.ts
+const ARGS = {
+	check: {
+		type: "boolean",
+		description: "Fail when the SQL file is out of date"
+	},
+	apply: {
+		type: "boolean",
+		description: "Also insert the rows into the database ($DATABASE_URL, --db-url-stdin, or the local stack)"
+	},
+	entry: {
+		type: "string",
+		description: "Defaults to seed.entry (supabase/seed.ts)",
+		valueHint: "file"
+	},
+	out: {
+		type: "string",
+		description: "Defaults to seed.output (supabase/seeds/000_better_supabase.sql)",
+		valueHint: "file"
+	},
+	"db-url-stdin": {
+		type: "boolean",
+		description: "Read the connection string from stdin instead of $DATABASE_URL or the config"
+	}
+};
+const HEADER = "-- Generated by `better-supabase seed`";
+async function runSeed(config, args, env, open = connect, dbUrl) {
+	const entry = args.entry ?? config.seed.entry;
+	const out = args.out ?? config.seed.output;
+	const seed = await importExport(resolve(config.root, entry), "seed");
+	if (!isSeed(seed)) return {
+		code: 1,
+		error: `${display(config.root, entry)} must export defineSeed(...) as \`seed\` or default.`
+	};
+	const statements = seed.statements();
+	const contents = `${HEADER} from ${display(config.root, entry)}. Do not edit.\n\n${statements.join("\n\n")}\n`;
+	const path = resolve(config.root, out);
+	const current = existsSync(path) ? await readFile(path, "utf8") : void 0;
+	if (args.check === true) return current === contents ? {
+		code: 0,
+		output: `${display(config.root, out)} is up to date.`
+	} : {
+		code: 1,
+		error: `${display(config.root, out)} is out of date. Run \`better-supabase seed\`.`
+	};
+	if (current !== void 0 && !current.startsWith(HEADER)) return {
+		code: 1,
+		error: `${display(config.root, out)} was not written by better-supabase; pass --out to write elsewhere.`
+	};
+	const lines = [`${await writeIfChanged(path, contents) ? "Wrote" : "Unchanged"} ${display(config.root, out)} (${statements.length} table${statements.length === 1 ? "" : "s"})`];
+	if (args.apply === true) {
+		const { client, close } = await open(await databaseUrl(config, env, dbUrl));
+		try {
+			await client.query("begin");
+			for (const text of statements) await client.query(text);
+			await client.query("commit");
+		} catch (error) {
+			await client.query("rollback");
+			throw error;
+		} finally {
+			await close();
+		}
+		lines.push("Inserted the fixtures (existing rows were kept).");
+	}
+	const toml = resolve(config.root, "supabase/config.toml");
+	const seedPath = out.startsWith("supabase/") ? `./${out.slice(9)}` : out;
+	if (existsSync(toml)) {
+		const text = await readFile(toml, "utf8");
+		const folder = seedPath.replace(/[^/]+$/, "");
+		if (!text.includes(seedPath) && !text.includes(`${folder}*`)) lines.push("", "Add it to supabase/config.toml so `supabase db reset` runs it:", "  [db.seed]", `  sql_paths = ["./seed.sql", "${seedPath}"]`);
+	}
+	return {
+		code: 0,
+		output: lines.join("\n")
+	};
+}
+const seedCommand = defineCliCommand({
+	meta: {
+		name: "seed",
+		description: "Renders the fixtures from defineSeed() (better-supabase/testing) to SQL"
+	},
+	args: ARGS,
+	run: async (args, { config, env, io }) => {
+		const dbUrl = await stdinDatabaseUrl(args["db-url-stdin"], io);
+		return withSpinner(args.apply === true ? io.prompts : void 0, "Inserting the seed rows", () => runSeed(config, args, env, connect, dbUrl));
+	}
+});
+//#endregion
+export { seedCommand };

package/dist/cli/skills-LJJIhLFR.js

@@ -0,0 +1,137 @@
+import { a as list, r as defineCliCommand } from "./command-CK14fP91.js";
+import { r as writeIfChanged, t as display } from "./io-k41_z-jT.js";
+import { t as byCodePoint } from "./compare-BmIWVEui.js";
+import { dirname, join, resolve } from "node:path";
+import { existsSync } from "node:fs";
+import { readFile, readdir } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { homedir } from "node:os";
+//#region src/cli/commands/skills.ts
+const ARGS = {
+	action: {
+		type: "positional",
+		required: false,
+		description: "list or install"
+	},
+	agent: {
+		type: "string",
+		description: "cursor (.cursor/skills), claude (.claude/skills) or agents (.agents/skills). Defaults to the agent folders the project has, else agents",
+		valueHint: "names"
+	},
+	global: {
+		type: "boolean",
+		description: "Install into your home directory instead of the project"
+	},
+	check: {
+		type: "boolean",
+		description: "Fail when installed skills differ from this version"
+	},
+	from: {
+		type: "string",
+		description: "Read skills from this folder instead of the package",
+		valueHint: "dir"
+	}
+};
+const AGENT_DIRS = {
+	cursor: ".cursor/skills",
+	claude: ".claude/skills",
+	agents: ".agents/skills"
+};
+const isAgent = (name) => name in AGENT_DIRS;
+/** The `skills/` folder of the `better-supabase` package this CLI depends on. */
+function skillsRoot() {
+	const root = join(dirname(fileURLToPath(import.meta.resolve("better-supabase/package.json"))), "skills");
+	if (!existsSync(root)) throw new Error("Could not find the better-supabase skills folder.");
+	return root;
+}
+async function readTree(root, prefix = "") {
+	const files = [];
+	const entries = await readdir(join(root, prefix), { withFileTypes: true });
+	for (const entry of entries.sort((a, b) => byCodePoint(a.name, b.name))) {
+		const path = prefix ? `${prefix}/${entry.name}` : entry.name;
+		if (entry.isDirectory()) files.push(...await readTree(root, path));
+		else if (entry.isFile()) files.push({
+			path,
+			contents: await readFile(join(root, path), "utf8")
+		});
+	}
+	return files;
+}
+async function loadSkills(root = skillsRoot()) {
+	const skills = [];
+	for (const entry of (await readdir(root, { withFileTypes: true })).filter((item) => item.isDirectory())) {
+		const folder = join(root, entry.name);
+		if (!existsSync(join(folder, "SKILL.md"))) continue;
+		const tree = await readTree(folder);
+		const main = tree.find((file) => file.path === "SKILL.md");
+		const files = [main, ...tree.filter((file) => file !== main)];
+		const description = /^description:\s*(.+)$/m.exec(main.contents)?.[1] ?? "";
+		skills.push({
+			name: entry.name,
+			description,
+			contents: main.contents,
+			files
+		});
+	}
+	return skills.sort((a, b) => byCodePoint(a.name, b.name));
+}
+async function runSkills(config, args, env) {
+	const [action] = args._;
+	const skills = await loadSkills(args.from ?? skillsRoot());
+	if (action === "list") return {
+		code: 0,
+		output: skills.map((skill) => `${skill.name}\n  ${skill.description}`).join("\n")
+	};
+	if (action !== "install") return {
+		code: 2,
+		error: `${action ? `Unknown skills action "${action}"` : "Name an action"}. Use \`skills list\` or \`skills install\`.`
+	};
+	const global = args.global === true;
+	const base = global ? env.HOME ?? homedir() : config.root;
+	const requested = list(args.agent);
+	const unknown = requested.filter((name) => !isAgent(name));
+	if (unknown.length > 0) return {
+		code: 2,
+		error: `Unknown agent ${unknown.join(", ")}. Use ${Object.keys(AGENT_DIRS).join(", ")}.`
+	};
+	const detected = Object.keys(AGENT_DIRS).filter((agent) => existsSync(join(base, AGENT_DIRS[agent].split("/")[0])));
+	const agents = requested.length > 0 ? requested.filter(isAgent) : detected.length > 0 ? detected : ["agents"];
+	const check = args.check === true;
+	const lines = [];
+	const stale = [];
+	const targets = agents.flatMap((agent) => skills.flatMap((skill) => skill.files.map((file) => ({
+		file,
+		relativePath: join(AGENT_DIRS[agent], skill.name, file.path)
+	}))));
+	for (const { file, relativePath } of targets) {
+		const path = resolve(base, relativePath);
+		const shown = global ? `~/${relativePath}` : display(config.root, relativePath);
+		if (check) {
+			if ((existsSync(path) ? await readFile(path, "utf8") : void 0) !== file.contents) stale.push(shown);
+			continue;
+		}
+		lines.push(`${await writeIfChanged(path, file.contents) ? "Wrote" : "Unchanged"} ${shown}`);
+	}
+	if (check) return stale.length === 0 ? {
+		code: 0,
+		output: "Skills are up to date."
+	} : {
+		code: 1,
+		error: `Out of date: ${stale.join(", ")}. Run \`better-supabase skills install\`.`
+	};
+	return {
+		code: 0,
+		output: lines.join("\n")
+	};
+}
+const skillsCommand = defineCliCommand({
+	meta: {
+		name: "skills",
+		description: "Installs the Agent Skills that ship with this version of better-supabase"
+	},
+	args: ARGS,
+	lists: ["agent"],
+	run: (args, { config, env }) => runSkills(config, args, env)
+});
+//#endregion
+export { skillsCommand };

package/dist/cli/sql-DzPbfngx.js

@@ -0,0 +1,348 @@
+import { r as defineCliCommand } from "./command-CK14fP91.js";
+import { r as writeIfChanged, t as display } from "./io-k41_z-jT.js";
+import { i as plain, r as painter } from "./style-C0NFdJRL.js";
+import { f as readSupabaseToml, p as schemaPaths, u as migrationCommand } from "./config-CPVpXP5I.js";
+import { t as fileDiff } from "./diff-SjkO5rNr.js";
+import { o as permdockSource, r as entitlementsMode, s as readPermdock, t as compiledReadSets } from "./read-sets-BfMQcKy8.js";
+import { dirname, join, relative, resolve, sep } from "node:path";
+import { existsSync } from "node:fs";
+import { readFile, readdir } from "node:fs/promises";
+import { SQL_MODULES, contractSignature, customContracts, kitFileVersion, kitLayout, moduleBody, renderKit, resolveModules, sameKitFile, upgradePlan } from "better-supabase/sql";
+//#region src/cli/commands/sql.ts
+const SQL_ARGS = {
+	action: {
+		type: "positional",
+		required: false,
+		description: "list (modules and whether they are installed), add <module...>, sync, upgrade, data (a migration with the rows a schema diff skips) or print <module>"
+	},
+	check: {
+		type: "boolean",
+		description: "With sync: fail when a file is stale. With upgrade: fail when a module is behind"
+	},
+	"tests-dir": {
+		type: "string",
+		description: "Where the pgtap module goes. Defaults to sql.testsDir",
+		valueHint: "dir"
+	},
+	"dry-run": {
+		type: "boolean",
+		description: "Show what would be written"
+	},
+	force: {
+		type: "boolean",
+		description: "Write tenant even though a permdock.config.ts is present"
+	}
+};
+const USAGE = "Run `better-supabase sql --help` for the actions.";
+/** Modules that fill a claim PermDock's hook also writes (`memberships`). */
+const PERMDOCK_OWNED = /* @__PURE__ */ new Set(["tenant"]);
+/**
+* PermDock's helpers for the `entitlements` module. When `names` resolve to
+* that module, an invalid PermDock mode (no manifest, a scope it lacks, an
+* unknown id type) throws instead of falling back to the tenant module.
+* Without `names` (`sql list`) it only describes the modules, so it doesn't.
+*/
+async function permdockFor(config, names) {
+	const mode = entitlementsMode(config, await readPermdock(config.root, config.permdock));
+	switch (mode.kind) {
+		case "tenant": return;
+		case "permdock": return mode.permdock;
+		case "invalid":
+			if (names === void 0 || !resolveModules(names, {}).some((module) => module.name === "entitlements")) return void 0;
+			throw new TypeError(mode.problem);
+		default: return mode;
+	}
+}
+async function layout(config, args, names) {
+	return kitLayout(config, args["tests-dir"], [], await permdockFor(config, names));
+}
+/** The layout, with `config.readSets` compiled when `names` includes `read-sets`. */
+async function layoutFor(config, args, names) {
+	const permdock = await permdockFor(config, names);
+	const needsReadSets = resolveModules(names, { ...permdock ? { permdock } : {} }).some((module) => module.name === "read-sets");
+	return kitLayout(config, args["tests-dir"], needsReadSets ? await compiledReadSets(config) : [], permdock);
+}
+/**
+* The migrations folder next to the `config.toml` found walking up from
+* `sql.dir`, relative to the root; `supabase/migrations` without one. The
+* walk stops where `sql.dir` and the root meet, so a `sql.dir` outside the
+* project (a shared stack in a monorepo) finds that stack's folder.
+*/
+function migrationsDir(config) {
+	const root = resolve(config.root);
+	let dir = resolve(root, config.sql.dir);
+	let stop = root;
+	while (dir !== stop && !dir.startsWith(stop + sep) && dirname(stop) !== stop) stop = dirname(stop);
+	for (;;) {
+		if (existsSync(join(dir, "config.toml"))) return relative(root, join(dir, "migrations")).replaceAll("\\", "/");
+		if (dir === stop || dirname(dir) === dir) break;
+		dir = dirname(dir);
+	}
+	return "supabase/migrations";
+}
+/** `YYYYMMDDHHMMSS` in UTC, the Supabase CLI's migration prefix. */
+const migrationStamp = (now) => now.toISOString().replaceAll(/[-:T]/g, "").slice(0, 14);
+/**
+* A stamp for `now`, or one second after the newest migration when that one
+* has the same stamp or a later one: the Supabase CLI keys migrations by
+* stamp, and the data has to run after the schema.
+*/
+function stampAfter(migrations, now) {
+	const newest = migrations.map((name) => /^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})_/.exec(name)).filter((match) => match !== null).map((match) => Date.UTC(Number(match[1]), Number(match[2]) - 1, Number(match[3]), Number(match[4]), Number(match[5]), Number(match[6]))).reduce((max, time) => Math.max(max, time), Number.NEGATIVE_INFINITY);
+	const at = Math.floor(now.getTime() / 1e3) * 1e3;
+	return migrationStamp(new Date(Math.max(at, newest + 1e3)));
+}
+async function write(config, args, names, kit) {
+	const lines = [];
+	const dryRun = args["dry-run"] === true;
+	let data = false;
+	for (const file of renderKit(names, kit)) {
+		const path = resolve(config.root, file.path);
+		const shown = display(config.root, file.path);
+		if (dryRun) {
+			lines.push(`Would write ${shown} (${file.module})`);
+			continue;
+		}
+		const wrote = await writeIfChanged(path, file.contents);
+		if (wrote && file.kind === "data") data = true;
+		lines.push(`${wrote ? "Wrote" : "Unchanged"} ${shown} (${file.module})`);
+	}
+	if (data) lines.push("", DATA_NEXT);
+	return lines;
+}
+const DATA_NEXT = "The better-supabase-data files hold rows and settings a schema diff skips: after the schema migration, run `better-supabase sql data`.";
+const DATA_SUFFIX = "_better_supabase_kit_data.sql";
+/**
+* Writes the data files of `sql.kit` into one migration, meant to run after
+* the schema migration that creates their tables. Every statement is
+* idempotent, so the migration carries all of them, not only the changes.
+*/
+async function dataMigration(config, args) {
+	if (config.sql.kit.length === 0) return {
+		code: 0,
+		output: "sql.kit is empty; nothing to write."
+	};
+	const files = renderKit(config.sql.kit, await layoutFor(config, args, config.sql.kit)).filter((file) => file.kind === "data");
+	const contents = `-- better-supabase sql data: the rows and settings of ${files.map((file) => file.module).join(", ")}, which a schema diff skips.\n\n${files.map((file) => file.contents.trim()).join("\n\n")}\n`;
+	const dir = migrationsDir(config);
+	const existing = await readdir(resolve(config.root, dir)).catch(() => []);
+	const latest = existing.toSorted().findLast((name) => name.endsWith(DATA_SUFFIX));
+	if (latest !== void 0 && await readFile(resolve(config.root, dir, latest), "utf8") === contents) return {
+		code: 0,
+		output: `${dir}/${latest} already has these rows; nothing to write.`
+	};
+	const path = `${dir}/${stampAfter(existing, /* @__PURE__ */ new Date())}${DATA_SUFFIX}`;
+	if (args["dry-run"] === true) return {
+		code: 0,
+		output: `Would write ${path}`
+	};
+	await writeIfChanged(resolve(config.root, path), contents);
+	return {
+		code: 0,
+		output: `Wrote ${path}`
+	};
+}
+/** A note when migra's `schema_paths` is set and misses kit files, which `supabase db diff` would then skip. */
+async function unlistedKitFiles(config, names, kit) {
+	const order = await schemaPaths(config.root, await readSupabaseToml(config.root));
+	if (!order.configured) return [];
+	const unlisted = new Set(order.unlisted);
+	const listed = new Set(order.files.filter((path) => !unlisted.has(path)));
+	const dir = `${config.sql.dir.replace(/\/$/, "")}/`;
+	const missing = renderKit(names, kit).filter((file) => file.kind !== "data").map((file) => file.path).filter((path) => path.startsWith(dir) && !listed.has(path));
+	if (missing.length === 0) return [];
+	return [
+		"",
+		"supabase/config.toml sets [db.migrations] schema_paths, and no entry matches these files, so `supabase db diff` skips them.",
+		"Add them before the schemas that call their functions:",
+		...missing.map((path) => `  "./${path.startsWith("supabase/") ? path.slice(9) : path}",`)
+	];
+}
+/**
+* Rewrites the kit files of modules behind the current version, and writes
+* their upgrade steps (renames, backfills) as a migration that runs before
+* the one the schema diff creates.
+*/
+async function upgrade(config, args, paint) {
+	if (config.sql.kit.length === 0) return {
+		code: 0,
+		output: "sql.kit is empty; nothing to upgrade."
+	};
+	const kit = await layoutFor(config, args, config.sql.kit);
+	const files = renderKit(config.sql.kit, kit);
+	const installed = [];
+	const stale = [];
+	const diffs = [];
+	for (const file of files) {
+		if (file.kind === "data") continue;
+		const current = await readFile(resolve(config.root, file.path), "utf8").catch(() => void 0);
+		if (current === void 0) continue;
+		installed.push({
+			module: file.module,
+			version: kitFileVersion(current)?.version ?? 1
+		});
+		if (!sameKitFile(current, file.contents)) {
+			stale.push(file);
+			diffs.push(fileDiff(display(config.root, file.path), current, file.contents, paint));
+		}
+	}
+	const plan = upgradePlan(installed, kit);
+	const behind = plan.map((entry) => `${entry.module} is at version ${String(entry.from)}; the current version is ${String(entry.to)}`);
+	if (args.check === true) {
+		if (plan.length === 0 && stale.length === 0) return {
+			code: 0,
+			output: "SQL kit modules are at their current versions."
+		};
+		return {
+			code: 1,
+			output: diffs.join("\n\n"),
+			error: [
+				...behind,
+				...stale.length > 0 ? [`Out of date: ${stale.map((file) => display(config.root, file.path)).join(", ")}.`] : [],
+				"Run `better-supabase sql upgrade`."
+			].join("\n")
+		};
+	}
+	if (plan.length === 0 && stale.length === 0) return {
+		code: 0,
+		output: "SQL kit modules are at their current versions."
+	};
+	const lines = [];
+	const steps = plan.flatMap((entry) => entry.steps.filter((step) => step.sql !== "").map((step) => `-- ${entry.module}: version ${String(step.from)} to ${String(step.from + 1)}. ${step.description}\n${step.sql}`));
+	const dryRun = args["dry-run"] === true;
+	if (steps.length > 0) {
+		const path = `${migrationsDir(config)}/${migrationStamp(/* @__PURE__ */ new Date())}_better_supabase_kit_upgrade.sql`;
+		const contents = `-- better-supabase sql upgrade: steps that run before the schema diff.\n\n${steps.join("\n\n")}\n`;
+		if (dryRun) lines.push(`Would write ${path}`);
+		else {
+			await writeIfChanged(resolve(config.root, path), contents);
+			lines.push(`Wrote ${path}`);
+		}
+	}
+	for (const entry of plan) lines.push(`${entry.module}: version ${String(entry.from)} to ${String(entry.to)}`, ...entry.steps.map((step) => `  ${step.description}`));
+	lines.push(...await write(config, args, config.sql.kit, kit), "", `Then create a migration: ${migrationCommand(await readSupabaseToml(config.root), "better_supabase_kit")}`);
+	return {
+		code: 0,
+		output: lines.join("\n")
+	};
+}
+async function runSql(config, args, paint = plain) {
+	const [action, ...names] = args._;
+	switch (action) {
+		case "list": {
+			const kit = await layout(config, args);
+			const files = new Map(renderKit(Object.keys(SQL_MODULES), kit).filter((file) => file.kind !== "data").map((file) => [file.module, file.path]));
+			return {
+				code: 0,
+				output: `${Object.values(SQL_MODULES).map((module) => {
+					const path = files.get(module.name);
+					const installed = path !== void 0 && existsSync(resolve(config.root, path));
+					const tracked = config.sql.kit.includes(module.name);
+					const mark = path === void 0 ? "◇" : installed ? tracked ? "●" : "○" : " ";
+					const requires = kit.permdock && module.permdockRequires ? module.permdockRequires : module.requires;
+					const needs = requires.length > 0 ? ` (needs ${requires.join(", ")})` : "";
+					return `${mark} ${module.name.padEnd(15)} ${module.description}${needs}`;
+				}).join("\n")}\n\n● installed and in sql.kit   ○ installed, not in sql.kit   ◇ custom mode (the app implements it)`
+			};
+		}
+		case "add": {
+			if (names.length === 0) return {
+				code: 2,
+				error: `Name at least one module.\n${USAGE}`
+			};
+			const unknown = names.filter((name) => !(name in SQL_MODULES));
+			if (unknown.length > 0) return {
+				code: 2,
+				error: `Unknown module ${unknown.join(", ")}. Available: ${Object.keys(SQL_MODULES).join(", ")}`
+			};
+			const project = await readPermdock(config.root, config.permdock);
+			const permdock = project ? permdockSource(project) : void 0;
+			const hookModules = names.filter((name) => PERMDOCK_OWNED.has(name));
+			if (permdock && hookModules.length > 0 && args.force !== true) return {
+				code: 1,
+				error: [
+					`${permdock} is present, so PermDock owns the access token hook and the memberships claim.`,
+					`${hookModules.join(" and ")} would add a second source for them. Use \`permdock supabase hook generate\` instead,`,
+					"or pass --force to write the modules anyway."
+				].join("\n")
+			};
+			const kit = await layoutFor(config, args, names);
+			const lines = await write(config, args, names, kit);
+			const pulledIn = resolveModules(names, kit).map((module) => module.name).filter((name) => PERMDOCK_OWNED.has(name) && !names.includes(name));
+			if (permdock && pulledIn.length > 0) lines.push("", `${pulledIn.join(" and ")} came along as a dependency: its memberships table backs has_org_role() and has_entitlement().`, `PermDock's hook still owns the memberships claim, so don't call better_supabase.membership_claims from a hook.`, "List better_supabase.memberships as a PermDock membership source if both should agree.");
+			const untracked = resolveModules(names, kit).map((module) => module.name).filter((name) => !config.sql.kit.includes(name));
+			if (untracked.length > 0) lines.push("", `Add them to your config so \`sql sync --check\` keeps them current:`, `  sql: { kit: [${[...config.sql.kit, ...untracked].map((name) => `'${name}'`).join(", ")}] }`);
+			if (args["dry-run"] !== true) lines.push(...await unlistedKitFiles(config, names, kit));
+			lines.push("", `Then create a migration: ${migrationCommand(await readSupabaseToml(config.root), "better_supabase_kit")}`);
+			return {
+				code: 0,
+				output: lines.join("\n")
+			};
+		}
+		case "sync": {
+			if (config.sql.kit.length === 0) return {
+				code: 0,
+				output: "sql.kit is empty; nothing to sync."
+			};
+			if (args.check !== true) return {
+				code: 0,
+				output: (await write(config, args, config.sql.kit, await layoutFor(config, args, config.sql.kit))).join("\n")
+			};
+			const stale = [];
+			const diffs = [];
+			for (const file of renderKit(config.sql.kit, await layoutFor(config, args, config.sql.kit))) {
+				const current = await readFile(resolve(config.root, file.path), "utf8").catch(() => void 0);
+				if (!sameKitFile(current, file.contents)) {
+					const shown = display(config.root, file.path);
+					stale.push(shown);
+					diffs.push(fileDiff(shown, current, file.contents, paint));
+				}
+			}
+			return stale.length === 0 ? {
+				code: 0,
+				output: "SQL kit files are up to date."
+			} : {
+				code: 1,
+				output: diffs.join("\n\n"),
+				error: `Out of date: ${stale.join(", ")}. Run \`better-supabase sql sync\`.`
+			};
+		}
+		case "upgrade": return upgrade(config, args, paint);
+		case "data": return dataMigration(config, args);
+		case "print": {
+			const [name] = names;
+			const module = name ? SQL_MODULES[name] : void 0;
+			if (!module) return {
+				code: 2,
+				error: `Name one module: ${Object.keys(SQL_MODULES).join(", ")}`
+			};
+			const body = moduleBody(module.name, await layout(config, args, [module.name]));
+			if (body === void 0) return {
+				code: 0,
+				output: `-- kits.${module.name} is in custom mode: the app writes these functions.\n${customContracts([module.name], await layout(config, args, [module.name])).flatMap((contract) => contract.functions.map((fn) => `-- ${contract.schema}.${fn.name}(${contractSignature(fn, contract.idType)}) returns ${fn.returns.replaceAll("{id}", contract.idType)}`)).join("\n")}`
+			};
+			return {
+				code: 0,
+				output: body
+			};
+		}
+		case void 0: return {
+			code: 2,
+			error: `Name an action.\n${USAGE}`
+		};
+		default: return {
+			code: 2,
+			error: `Unknown sql action "${action}".\n${USAGE}`
+		};
+	}
+}
+const sqlCommand = defineCliCommand({
+	meta: {
+		name: "sql",
+		description: "Lists, adds, syncs, upgrades and prints SQL kit modules, and writes their data migration"
+	},
+	args: SQL_ARGS,
+	run: (args, { config, io }) => runSql(config, args, painter(io.color))
+});
+//#endregion
+export { sqlCommand };

package/dist/cli/style-C0NFdJRL.js

@@ -0,0 +1,29 @@
+import { styleText } from "node:util";
+//#region src/cli/style.ts
+const plain = (_format, text) => text;
+const colored = (format, text) => styleText(format, text, { validateStream: false });
+function painter(color) {
+	return color === true ? colored : plain;
+}
+/** Whether stdout takes colors: a TTY, and neither `NO_COLOR` nor `NODE_DISABLE_COLORS` set (`FORCE_COLOR` overrides). */
+function colorEnabled() {
+	return styleText("red", "x", { stream: process.stdout }) !== "x";
+}
+const VERBS = [
+	[/^(?:Wrote|Updated)\b/, "green"],
+	[/^Would write\b/, "yellow"],
+	[/^(?:Unchanged|Kept|Same)\b/, "dim"]
+];
+/** Colors the verb that starts each `Wrote`, `Kept`, `Unchanged` or `Would write` line. */
+function highlight(text, paint) {
+	if (paint === plain) return text;
+	return text.split("\n").map((line) => {
+		for (const [pattern, format] of VERBS) {
+			const verb = pattern.exec(line)?.[0];
+			if (verb) return `${paint(format, verb)}${line.slice(verb.length)}`;
+		}
+		return line;
+	}).join("\n");
+}
+//#endregion
+export { plain as i, highlight as n, painter as r, colorEnabled as t };