@better-schemic/cli 0.1.0-alpha.1

package/lib/cli.js

@@ -0,0 +1,2014 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { spawnSync } from "child_process";
+import {
+  existsSync as existsSync3,
+  watch as fsWatch,
+  mkdirSync as mkdirSync3,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { dirname as dirname4, join as join3, relative as relative2 } from "path";
+import { createInterface as createInterface2 } from "readline/promises";
+import {
+  actionLabel,
+  applyPull,
+  duplicateTables,
+  EMPTY_STORED as EMPTY_STORED2,
+  existingTables,
+  fail as fail3,
+  formatDiff,
+  formatItems as formatItems2,
+  formatPatch,
+  getDriver as getDriver5,
+  isEmptyDiff as isEmptyDiff2,
+  kindFlags,
+  lineDiff,
+  listMigrations as listMigrations2,
+  loadDefs as loadDefs4,
+  loadSchemas,
+  lowerSchema as lowerSchema4,
+  ok as ok3,
+  parseFilter as parseFilter2,
+  pipeThroughPager,
+  plural as plural2,
+  readSnapshot as readSnapshot3,
+  resolvePager,
+  snapshotObjects as snapshotObjects3,
+  style as style6,
+  summarizeKinds,
+  unifiedDiff,
+  writeSnapshot as writeSnapshot2
+} from "@better-schemic/core";
+import { Command, Help, Option } from "commander";
+
+// package.json
+var version = "0.1.0-alpha.1";
+
+// src/cli/action.ts
+import { fail, style } from "@better-schemic/core";
+var debugEnabled = () => !!process.env.BETTER_SCHEMIC_DEBUG || !!process.env.SCHEMIC_DEBUG;
+var errMsg = (err) => err instanceof Error ? err.message : String(err);
+function runAction(action) {
+  action().then(
+    () => process.exit(process.exitCode ?? 0),
+    (err) => {
+      console.error(`
+${fail(errMsg(err))}`);
+      if (debugEnabled() || process.argv.includes("--stack")) {
+        for (let e = err, depth = 0; e && depth < 8; depth++) {
+          console.error(
+            style.dim(e instanceof Error ? e.stack ?? String(e) : String(e))
+          );
+          e = e instanceof Error ? e.cause : void 0;
+          if (e) console.error(style.dim("caused by:"));
+        }
+      } else {
+        console.error(
+          style.dim(
+            "(re-run with BETTER_SCHEMIC_DEBUG=1 or --stack for the stack trace)"
+          )
+        );
+      }
+      process.exit(1);
+    }
+  );
+}
+
+// src/cli/driver-commands.ts
+import { createInterface } from "readline/promises";
+import {
+  envSecretProvider,
+  fail as fail2,
+  getDriver as getDriver2,
+  loadProject as loadProject2,
+  ok,
+  style as style3
+} from "@better-schemic/core";
+
+// src/cli/inspect.ts
+import {
+  loadDefs,
+  lowerSchema,
+  readSnapshot,
+  snapshotObjects,
+  style as style2
+} from "@better-schemic/core";
+
+// src/cli/resolve.ts
+import { readFileSync } from "fs";
+import { createRequire } from "module";
+import { dirname, join } from "path";
+import { pathToFileURL } from "url";
+import {
+  driverNames,
+  getDriver,
+  isConnectionEntry,
+  loadProject,
+  resolveConnectionConfig
+} from "@better-schemic/core";
+function pickCompiled(node) {
+  if (typeof node === "string") return node;
+  if (node && typeof node === "object") {
+    const o = node;
+    return pickCompiled(o.import) ?? pickCompiled(o.default) ?? pickCompiled(o.require);
+  }
+  return void 0;
+}
+function compiledEntry(pkg, base, subpath) {
+  try {
+    const manifestPath = createRequire(base).resolve(`${pkg}/package.json`);
+    const m = JSON.parse(readFileSync(manifestPath, "utf8"));
+    const exp = pickCompiled(m.exports?.[subpath]);
+    const rel = subpath === "." ? exp ?? m.module ?? m.main ?? "index.js" : exp;
+    return rel ? join(dirname(manifestPath), rel) : null;
+  } catch {
+    return null;
+  }
+}
+async function ensureDriver(name) {
+  if (driverNames().includes(name)) return;
+  const pkgs = [`@better-schemic/${name}`, `@schemic/${name}`];
+  const pkg = pkgs[0];
+  let lastErr;
+  let loaded = false;
+  for (const candidate of pkgs) {
+    for (const base of [join(process.cwd(), "noop.js"), import.meta.url]) {
+      const entry = compiledEntry(candidate, base, "./driver");
+      if (!entry) continue;
+      try {
+        await import(pathToFileURL(entry).href);
+        loaded = true;
+        break;
+      } catch (e) {
+        lastErr = e;
+      }
+    }
+    if (loaded) break;
+    try {
+      await import(`${candidate}/driver`);
+      loaded = true;
+      break;
+    } catch (e) {
+      lastErr = e;
+    }
+  }
+  if (!loaded)
+    throw new Error(
+      `could not load the "${name}" database driver from ${pkg}/driver. Install it (and ensure it's >= 0.1.0-alpha.1, which exposes the /driver entry):
+    bun add ${pkg}
+  (${lastErr instanceof Error ? lastErr.message : String(lastErr)})`
+    );
+  if (!driverNames().includes(name))
+    throw new Error(
+      `package ${pkg}/driver did not register a "${name}" driver.`
+    );
+}
+function collectArg(value, prev) {
+  return [...prev, value];
+}
+function parseArgs(arg, argsJson) {
+  const out = {};
+  if (argsJson) {
+    try {
+      Object.assign(out, JSON.parse(argsJson));
+    } catch {
+      throw new Error(`--args must be a JSON object (got "${argsJson}").`);
+    }
+  }
+  for (const a of arg ?? []) {
+    const i = a.indexOf("=");
+    if (i < 0) throw new Error(`--arg must be key=value (got "${a}").`);
+    out[a.slice(0, i)] = a.slice(i + 1);
+  }
+  return out;
+}
+function splitAddress(address) {
+  const i = address.indexOf(":");
+  return i < 0 ? [address, void 0] : [address.slice(0, i), address.slice(i + 1)];
+}
+async function resolveTargets(opts) {
+  const { config, root } = await loadProject({ config: opts.config });
+  const args = parseArgs(opts.arg, opts.args);
+  const names = Object.keys(config.connections);
+  const opened = /* @__PURE__ */ new Map();
+  const resolving = /* @__PURE__ */ new Set();
+  const entryOf = (name) => {
+    const entry = config.connections[name];
+    if (!isConnectionEntry(entry))
+      throw new Error(
+        `No connection named "${name}". Known: ${names.join(", ") || "(none)"}.`
+      );
+    return entry;
+  };
+  const resolveOneConfig = async (name, key) => {
+    const entry = entryOf(name);
+    const list = await entry.resolve(ctx, args);
+    const picked = key !== void 0 ? list.find((c) => c.key === key) : list.length === 1 ? list[0] : void 0;
+    if (!picked) {
+      if (key !== void 0)
+        throw new Error(
+          `Connection "${name}" has no element with key "${key}".`
+        );
+      throw new Error(
+        `Connection "${name}" resolved to ${list.length} connections (a collection); address one with --connection ${name}:<key> or use --all.`
+      );
+    }
+    return resolveConnectionConfig(config, name, picked, entry.driver, root);
+  };
+  const openConnection = async (name) => {
+    const cached = opened.get(name);
+    if (cached) return cached;
+    if (resolving.has(name))
+      throw new Error(`Connection cycle detected while resolving "${name}".`);
+    resolving.add(name);
+    try {
+      const resolved = await resolveOneConfig(name);
+      await ensureDriver(resolved.driver);
+      const driver = getDriver(resolved.driver);
+      const conn = await driver.connect(resolved, opts);
+      const handle = { driver, conn, driverName: resolved.driver };
+      opened.set(name, handle);
+      return handle;
+    } finally {
+      resolving.delete(name);
+    }
+  };
+  const connections = new Proxy(
+    {},
+    {
+      get(_t, prop) {
+        if (typeof prop !== "string") return void 0;
+        return {
+          async query(sql, vars) {
+            const { driver, conn, driverName } = await openConnection(prop);
+            if (!driver.query)
+              throw new Error(
+                `the "${driverName}" driver has no \`query\` capability (needed by a connection resolver).`
+              );
+            return driver.query(conn, sql, vars);
+          }
+        };
+      }
+    }
+  );
+  const ctx = { connections, env: process.env };
+  const fanOut = async (name) => {
+    const entry = entryOf(name);
+    const list = await entry.resolve(ctx, args);
+    return list.map(
+      (conn) => resolveConnectionConfig(config, name, conn, entry.driver, root)
+    );
+  };
+  try {
+    let targets;
+    if (opts.all) {
+      targets = [];
+      for (const name of names) targets.push(...await fanOut(name));
+    } else if (opts.connection) {
+      const [name, key] = splitAddress(opts.connection);
+      targets = key !== void 0 ? [await resolveOneConfig(name, key)] : await fanOut(name);
+    } else {
+      const name = config.defaultConnection ?? (names.length === 1 ? names[0] : "default");
+      if (!config.connections[name])
+        throw new Error(
+          `No default connection. Set "defaultConnection" or pass --connection. Known: ${names.join(", ") || "(none)"}.`
+        );
+      targets = [await resolveOneConfig(name)];
+    }
+    if (!targets.length)
+      throw new Error("No connections matched \u2014 nothing to do.");
+    for (const driver of new Set(targets.map((t) => t.driver)))
+      await ensureDriver(driver);
+    return targets;
+  } finally {
+    for (const { driver, conn } of opened.values()) {
+      try {
+        await driver.close(conn);
+      } catch {
+      }
+    }
+  }
+}
+async function resolveOne(opts) {
+  if (opts.all)
+    throw new Error(
+      "--all is not supported here \u2014 this command operates on a single connection. Use --connection <name>."
+    );
+  const targets = await resolveTargets(opts);
+  if (targets.length !== 1)
+    throw new Error(
+      `--connection addressed ${targets.length} connections (a collection) \u2014 pin one with --connection <name>:<key>.`
+    );
+  return targets[0];
+}
+
+// src/cli/inspect.ts
+function pickSource(opts) {
+  if (opts.snapshot && opts.live)
+    throw new Error("--snapshot and --live are mutually exclusive");
+  if (opts.snapshot) return "snapshot";
+  if (opts.live) return "live";
+  return "declared";
+}
+function engineMap(registry) {
+  return new Map(registry.entries());
+}
+function requireKind(registry, engines, kind) {
+  const engine = engines.get(kind);
+  if (!engine)
+    throw new Error(
+      `unknown kind "${kind}" \u2014 expected one of: ${registry.names().join(", ")}`
+    );
+  return engine;
+}
+function parentName(engine, obj) {
+  return (engine?.parent?.(obj) ?? engine?.owner?.(obj))?.name;
+}
+function addressOf(engine, obj) {
+  const parent = parentName(engine, obj);
+  return parent ? `${parent}.${obj.name}` : obj.name;
+}
+async function loadObjects(source, driver, config) {
+  if (source === "declared") {
+    const { tables, defs } = await loadDefs(config.schemaPath);
+    return lowerSchema(driver.registry, driver.explode(tables, defs));
+  }
+  if (source === "snapshot") {
+    try {
+      return snapshotObjects(readSnapshot(config.metaDir).schema);
+    } catch {
+      return [];
+    }
+  }
+  const conn = await driver.connect(config);
+  try {
+    return await driver.introspectAll(conn);
+  } finally {
+    await driver.close(conn);
+  }
+}
+function addressesOfKind(engine, kind, objects) {
+  return objects.filter((o) => o.kind === kind).map((o) => addressOf(engine, o)).sort();
+}
+async function lsKind(kind, engine, registry, driver, config, source, json) {
+  const objects = await loadObjects(source, driver, config);
+  const addresses = addressesOfKind(engine, kind, objects);
+  if (json) {
+    console.log(JSON.stringify({ kind, source, entities: addresses }, null, 2));
+    return;
+  }
+  console.log(
+    style2.bold(
+      `${registry.display(kind).plural} (${addresses.length}) \u2014 ${source}`
+    )
+  );
+  if (!addresses.length) console.log(style2.dim("  (none)"));
+  for (const address of addresses) console.log(`  ${address}`);
+}
+async function infoKind(kind, address, engine, driver, config, source, json) {
+  const objects = await loadObjects(source, driver, config);
+  const found = objects.find(
+    (o) => o.kind === kind && addressOf(engine, o) === address
+  );
+  if (!found) throw new Error(`no ${kind} "${address}" in ${source}`);
+  if (json) {
+    console.log(
+      JSON.stringify(
+        { kind, address, source, ddl: engine.emit(found) },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  console.log(engine.emit(found).join("\n"));
+}
+async function overview(registry, driver, config, source, json) {
+  const objects = await loadObjects(source, driver, config);
+  const engines = engineMap(registry);
+  const rows = registry.names().map((kind) => ({
+    kind,
+    label: registry.display(kind).plural,
+    count: addressesOfKind(engines.get(kind), kind, objects).length
+  }));
+  if (json) {
+    console.log(JSON.stringify({ source, kinds: rows }, null, 2));
+    return;
+  }
+  console.log(style2.bold(`Schema overview \u2014 ${source}`));
+  const width = Math.max(0, ...rows.map((r) => r.label.length));
+  for (const r of rows) console.log(`  ${r.label.padEnd(width)}  ${r.count}`);
+}
+function registerInspectVerbs(program2, driver, groupFor, resolveOpts) {
+  const registry = driver.registry;
+  const engines = engineMap(registry);
+  const srcOpts = (c) => c.option("--snapshot", "inspect the metaDir baseline (last `gen`)").option("--live", "inspect the live database (introspection)").option("--json", "output JSON");
+  for (const kind of registry.names()) {
+    const engine = engines.get(kind);
+    const group = groupFor(kind);
+    srcOpts(
+      group.command("ls").summary(`list ${registry.display(kind).plural.toLowerCase()}`)
+    ).action(
+      (opts) => runAction(async () => {
+        const config = await resolveOne(resolveOpts());
+        await lsKind(
+          kind,
+          engine,
+          registry,
+          driver,
+          config,
+          pickSource(opts),
+          !!opts.json
+        );
+      })
+    );
+    srcOpts(
+      group.command("info <name>").summary(`show one ${kind}'s resolved definition`)
+    ).action(
+      (name, opts) => runAction(async () => {
+        const config = await resolveOne(resolveOpts());
+        await infoKind(
+          kind,
+          name,
+          engine,
+          driver,
+          config,
+          pickSource(opts),
+          !!opts.json
+        );
+      })
+    );
+  }
+  srcOpts(
+    program2.command("ls [kind]").summary("overview of all kinds, or list one kind's entities").description(
+      "With no KIND: a cross-kind overview (kinds + counts). With a KIND: that kind's entities \u2014 the verb-first form of `sc <kind> ls`. `--snapshot`/`--live` switch the source (default: declared)."
+    )
+  ).action(
+    (kind, opts) => runAction(async () => {
+      const config = await resolveOne(resolveOpts());
+      if (kind)
+        await lsKind(
+          kind,
+          requireKind(registry, engines, kind),
+          registry,
+          driver,
+          config,
+          pickSource(opts),
+          !!opts.json
+        );
+      else
+        await overview(registry, driver, config, pickSource(opts), !!opts.json);
+    })
+  );
+  srcOpts(
+    program2.command("info <kind> <name>").summary(
+      "show one entity's resolved definition (verb-first form of `sc <kind> info`)"
+    )
+  ).action(
+    (kind, name, opts) => runAction(async () => {
+      const config = await resolveOne(resolveOpts());
+      await infoKind(
+        kind,
+        name,
+        requireKind(registry, engines, kind),
+        driver,
+        config,
+        pickSource(opts),
+        !!opts.json
+      );
+    })
+  );
+}
+
+// src/cli/driver-commands.ts
+var io = {
+  ok: (m) => console.log(ok(m)),
+  fail: (m) => console.error(fail2(m)),
+  info: (m) => console.log(m),
+  async prompt(question, opts) {
+    if (!process.stdin.isTTY)
+      throw new Error(
+        `"${question}" needs an interactive terminal (no value was provided non-interactively)`
+      );
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    try {
+      if (opts?.hidden) {
+        const out = process.stdout;
+        const onData = () => out.write("\x1B[2K\r");
+        process.stdin.on("data", onData);
+        try {
+          return (await rl.question(`${question} `)).trim();
+        } finally {
+          process.stdin.off("data", onData);
+        }
+      }
+      return (await rl.question(`${question} `)).trim();
+    } finally {
+      rl.close();
+    }
+  }
+};
+function configFromArgv(argv) {
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === "-c" || argv[i] === "--config") return argv[i + 1];
+    if (argv[i].startsWith("--config="))
+      return argv[i].slice("--config=".length);
+  }
+  return void 0;
+}
+function toParsedArgs(cmd, positionals, opts) {
+  const flags = {};
+  for (const f of cmd.args?.flags ?? []) {
+    const v = opts[f.name];
+    flags[f.name] = f.value ? v : v === true;
+    if (f.required && (v === void 0 || v === false))
+      throw new Error(`\`sc ${cmd.kind} ${cmd.verb}\` requires --${f.name}`);
+  }
+  return { positionals, flags };
+}
+function addCommand(kindGroup, cmd, resolveOpts) {
+  const usage = (cmd.args?.positionals ?? []).map((p) => p.required ? `<${p.name}>` : `[${p.name}]`).join(" ");
+  const verb = kindGroup.command(`${cmd.verb} [args...]`).summary(cmd.summary).description(usage ? `${cmd.summary}
+
+Arguments: ${usage}` : cmd.summary);
+  for (const f of cmd.args?.flags ?? []) {
+    const flag = f.value ? `--${f.name} <value>` : `--${f.name}`;
+    verb.option(flag, f.help ?? "");
+  }
+  verb.action(
+    (args, opts) => runAction(async () => {
+      const parsed = toParsedArgs(cmd, args, opts);
+      const config = await resolveOne(resolveOpts());
+      const driver = getDriver2(config.driver);
+      const conn = await driver.connect(config);
+      const ctx = {
+        conn,
+        config,
+        io,
+        secrets: envSecretProvider
+      };
+      try {
+        await cmd.run(ctx, parsed);
+      } finally {
+        await driver.close(conn);
+      }
+    })
+  );
+}
+async function registerDriverCommands(program2) {
+  let driverName;
+  const configPath = configFromArgv(process.argv.slice(2));
+  try {
+    const { config } = await loadProject2({ config: configPath });
+    const entry = Object.values(config.connections)[0];
+    if (!entry?.driver) return;
+    driverName = entry.driver;
+  } catch {
+    return;
+  }
+  try {
+    await ensureDriver(driverName);
+  } catch {
+    return;
+  }
+  const driver = getDriver2(driverName);
+  const groups = /* @__PURE__ */ new Map();
+  const groupFor = (kind) => {
+    let g = groups.get(kind);
+    if (!g) {
+      g = program2.command(kind).summary(`inspect + manage ${style3.bold(kind)} resources`).description(
+        `\`${kind}\` commands: the universal \`ls\`/\`info\` (any kind) plus any driver verbs from @better-schemic/${driverName}.`
+      );
+      groups.set(kind, g);
+    }
+    return g;
+  };
+  const resolveOpts = () => {
+    const opts = program2.opts();
+    return { connection: opts.connection, config: opts.config ?? configPath };
+  };
+  registerInspectVerbs(program2, driver, groupFor, resolveOpts);
+  for (const cmd of driver.commands ?? []) {
+    addCommand(groupFor(cmd.kind), cmd, resolveOpts);
+  }
+}
+
+// src/cli/init.ts
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { dirname as dirname2, resolve } from "path";
+function initialSnapshot(driver) {
+  return `${JSON.stringify(
+    {
+      version: 3,
+      driver,
+      schema: { kinds: {} },
+      files: {}
+    },
+    null,
+    2
+  )}
+`;
+}
+function init(cwd, driver) {
+  const scaffold = driver.initScaffold?.();
+  if (!scaffold)
+    throw new Error(
+      `the "${driver.name}" driver does not support \`better-schemic init\` scaffolding.`
+    );
+  const files = {
+    ...scaffold,
+    "database/migrations/meta/_snapshot.json": initialSnapshot(driver.name)
+  };
+  const created = [];
+  const skipped = [];
+  for (const [rel, content] of Object.entries(files)) {
+    const abs = resolve(cwd, rel);
+    if (existsSync(abs)) {
+      skipped.push(rel);
+      continue;
+    }
+    mkdirSync(dirname2(abs), { recursive: true });
+    writeFileSync(abs, content);
+    created.push(rel);
+  }
+  return { created, skipped };
+}
+
+// src/cli/migrate.ts
+import {
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readdirSync,
+  readFileSync as readFileSync2,
+  rmSync,
+  statSync,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { dirname as dirname3, join as join2, relative, resolve as resolve2 } from "path";
+import {
+  buildKindDiff,
+  checksum,
+  EMPTY_STORED,
+  filterKinds,
+  getDriver as getDriver3,
+  intersectKinds,
+  isEmptyDiff,
+  listMigrations,
+  loadDefs as loadDefs2,
+  lowerSchema as lowerSchema2,
+  makeJiti,
+  mergeStored,
+  parseFilter,
+  readSnapshot as readSnapshot2,
+  slug,
+  snapshotKinds,
+  snapshotObjects as snapshotObjects2,
+  style as style4,
+  timestamp,
+  writeSnapshot
+} from "@better-schemic/core";
+function buildStored(driver, tables, defs, opts = {}) {
+  const objects = lowerSchema2(driver.registry, driver.explode(tables, defs));
+  const files = {};
+  const rel = (abs) => opts.root ? relative(opts.root, abs) : abs;
+  for (const t of tables) {
+    const abs = opts.fileOf?.get(t);
+    if (abs) files[t.name] = rel(abs);
+  }
+  for (const d of defs) {
+    const abs = opts.fileOf?.get(d);
+    const key = d.kind === "event" ? d.table : d.name;
+    if (abs && key) files[key] = rel(abs);
+  }
+  return {
+    version: 3,
+    driver: driver.name,
+    schema: snapshotKinds(objects, driver.registry),
+    files
+  };
+}
+function migStore(config) {
+  const driver = getDriver3(config.driver ?? "surrealdb");
+  if (!driver.migrations)
+    throw new Error(
+      `The "${driver.name}" driver does not support running migrations.`
+    );
+  return driver.migrations;
+}
+var migExt = (config) => getDriver3(config.driver ?? "surrealdb").migrations?.extension ?? ".surql";
+function attachFiles(diff, prevFiles, nextFiles) {
+  for (const it of diff.items ?? []) {
+    const primary = it.op === "remove" ? prevFiles : nextFiles;
+    it.file = primary[it.table] ?? nextFiles[it.table] ?? prevFiles[it.table];
+  }
+}
+async function planMigration(config, filter = parseFilter({}), opts = {}) {
+  const { tables, defs, fileOf } = await loadDefs2(config.schemaPath);
+  const driver = getDriver3(config.driver ?? "surrealdb");
+  const reg = driver.registry;
+  const next = buildStored(driver, tables, defs, { fileOf, root: config.root });
+  const prev = opts.baseline ? EMPTY_STORED : readSnapshot2(config.metaDir);
+  const diff = buildKindDiff(
+    reg,
+    filterKinds(reg, snapshotObjects2(prev.schema), filter),
+    filterKinds(reg, snapshotObjects2(next.schema), filter)
+  );
+  attachFiles(diff, prev.files ?? {}, next.files ?? {});
+  return { diff, next: mergeStored(reg, prev, next, filter) };
+}
+function nextTag(migrationsDir, name, ext) {
+  const s = slug(name);
+  const date = /* @__PURE__ */ new Date();
+  let tag = `${timestamp(date)}_${s}`;
+  while (existsSync2(join2(migrationsDir, `${tag}${ext}`))) {
+    date.setUTCSeconds(date.getUTCSeconds() + 1);
+    tag = `${timestamp(date)}_${s}`;
+  }
+  return tag;
+}
+function prepareMigration(config, plan, name) {
+  const { diff, next } = plan;
+  if (isEmptyDiff(diff)) return null;
+  mkdirSync2(config.migrationsDir, { recursive: true });
+  const ext = migExt(config);
+  const tag = nextTag(config.migrationsDir, name ?? "migration", ext);
+  return {
+    tag,
+    file: `${tag}${ext}`,
+    content: migStore(config).render(tag, diff),
+    next,
+    up: diff.up.length,
+    down: diff.down.length
+  };
+}
+function renderMigrationPreview(config, diff) {
+  return migStore(config).render("(unnamed)", diff);
+}
+function commitMigration(config, prepared) {
+  mkdirSync2(config.migrationsDir, { recursive: true });
+  writeFileSync2(join2(config.migrationsDir, prepared.file), prepared.content);
+  writeSnapshot(config.metaDir, prepared.next);
+  return {
+    created: true,
+    tag: prepared.tag,
+    file: prepared.file,
+    up: prepared.up,
+    down: prepared.down
+  };
+}
+async function recordApplied(db, config, m) {
+  await migStore(config).record(db, config.migrationsTable, {
+    tag: m.tag,
+    file: m.file,
+    checksum: checksum(m.content)
+  });
+}
+async function baseline(db, config, filter = parseFilter({})) {
+  const driver = getDriver3(config.driver ?? "surrealdb");
+  const reg = driver.registry;
+  const live = await driver.introspectAll(
+    db,
+    /* @__PURE__ */ new Set([config.migrationsTable, `${config.migrationsTable}_lock`])
+  );
+  const { tables, defs, fileOf } = await loadDefs2(config.schemaPath);
+  const disk = buildStored(driver, tables, defs, {
+    fileOf,
+    root: config.root
+  });
+  const pulledObjects = intersectKinds(
+    reg,
+    snapshotObjects2(disk.schema),
+    live,
+    filter
+  );
+  const pulled = {
+    version: 3,
+    driver: driver.name,
+    schema: snapshotKinds(pulledObjects, driver.registry),
+    files: disk.files
+  };
+  const prev = readSnapshot2(config.metaDir);
+  const diff = buildKindDiff(
+    reg,
+    filterKinds(reg, snapshotObjects2(prev.schema), filter),
+    pulledObjects
+  );
+  attachFiles(diff, prev.files ?? {}, pulled.files ?? {});
+  const plan = {
+    diff,
+    next: mergeStored(reg, prev, pulled, filter)
+  };
+  const prepared = prepareMigration(config, plan, "baseline");
+  if (!prepared) {
+    writeSnapshot(config.metaDir, plan.next);
+    return { created: false };
+  }
+  const res = commitMigration(config, prepared);
+  await recordApplied(db, config, prepared);
+  return res;
+}
+function clearMigrationFiles(config) {
+  const migs = listMigrations(config.migrationsDir, migExt(config));
+  for (const m of migs)
+    rmSync(join2(config.migrationsDir, m.file), { force: true });
+  return migs.map((m) => m.tag);
+}
+async function reconcileBaseline(db, config, prepared, drift) {
+  const mig = migStore(config);
+  await mig.ensure(db, config.migrationsTable);
+  if (drift) return "pending";
+  await mig.clear(db, config.migrationsTable);
+  await recordApplied(db, config, prepared);
+  return "applied";
+}
+function indexOfTag(migrations, tag) {
+  const i = migrations.findIndex((m) => m.tag === tag);
+  if (i < 0) throw new Error(`Unknown migration: ${tag}`);
+  return i;
+}
+async function unlock(db, config) {
+  await migStore(config).unlock(db, config.migrationsTable);
+}
+async function migrate(db, config, opts = {}) {
+  const mig = migStore(config);
+  const table = config.migrationsTable;
+  await mig.ensure(db, table);
+  const migrations = listMigrations(config.migrationsDir, migExt(config));
+  const applied = await mig.applied(db, table);
+  let pending = migrations.filter((m) => !applied.has(m.tag));
+  if (opts.to) {
+    const targetIdx = indexOfTag(migrations, opts.to);
+    const pos = new Map(migrations.map((m, i) => [m.tag, i]));
+    pending = pending.filter((m) => (pos.get(m.tag) ?? 0) <= targetIdx);
+  }
+  if (opts.count !== void 0)
+    pending = pending.slice(0, Math.max(0, opts.count));
+  await mig.lock(db, table);
+  try {
+    for (const m of pending) {
+      const content = readFileSync2(join2(config.migrationsDir, m.file), "utf8");
+      await mig.apply(db, table, {
+        content,
+        direction: "up",
+        record: { tag: m.tag, file: m.file, checksum: checksum(content) }
+      });
+    }
+  } finally {
+    await mig.unlock(db, table);
+  }
+  return { applied: pending };
+}
+function currentChecksum(config, m) {
+  const path = join2(config.migrationsDir, m.file);
+  if (!existsSync2(path)) return "";
+  return checksum(readFileSync2(path, "utf8"));
+}
+async function status(db, config) {
+  const mig = migStore(config);
+  await mig.ensure(db, config.migrationsTable);
+  const applied = await mig.applied(db, config.migrationsTable);
+  const files = listMigrations(config.migrationsDir, migExt(config));
+  const fileTags = new Set(files.map((m) => m.tag));
+  const rows = files.map((m) => {
+    const appliedSum = applied.get(m.tag);
+    return {
+      tag: m.tag,
+      applied: appliedSum !== void 0,
+      drift: appliedSum !== void 0 && appliedSum !== currentChecksum(config, m)
+    };
+  });
+  for (const tag of applied.keys())
+    if (!fileTags.has(tag)) rows.push({ tag, applied: true, missing: true });
+  return rows.sort((a, b) => a.tag.localeCompare(b.tag));
+}
+async function rollback(db, config, opts = {}) {
+  const mig = migStore(config);
+  const table = config.migrationsTable;
+  await mig.ensure(db, table);
+  const migrations = listMigrations(config.migrationsDir, migExt(config));
+  const applied = await mig.applied(db, table);
+  const appliedMigrations = migrations.filter((m) => applied.has(m.tag));
+  let toRevert;
+  if (opts.to) {
+    const targetIdx = indexOfTag(migrations, opts.to);
+    const pos = new Map(migrations.map((m, i) => [m.tag, i]));
+    toRevert = appliedMigrations.filter((m) => (pos.get(m.tag) ?? 0) > targetIdx).reverse();
+  } else {
+    toRevert = appliedMigrations.slice(-(opts.count ?? 1)).reverse();
+  }
+  await mig.lock(db, table);
+  try {
+    for (const m of toRevert) {
+      const content = readFileSync2(join2(config.migrationsDir, m.file), "utf8");
+      await mig.apply(db, table, {
+        content,
+        direction: "down",
+        record: { tag: m.tag, file: m.file, checksum: checksum(content) }
+      });
+    }
+  } finally {
+    await mig.unlock(db, table);
+  }
+  return toRevert;
+}
+var SEED_EXT = /\.(ts|mts|cts|js|mjs|cjs)$/;
+var SEED_ORDER_PREFIX = /^\d+[-_]/;
+function seedName(file) {
+  return file.replace(SEED_EXT, "").replace(SEED_ORDER_PREFIX, "");
+}
+function locateSeeds(config) {
+  const base = resolve2(config.root, config.seed ?? "database/seed");
+  if (existsSync2(base) && statSync(base).isDirectory()) {
+    let index;
+    const scripts = [];
+    for (const f of readdirSync(base).sort()) {
+      if (f.startsWith("_") || f.endsWith(".d.ts") || !SEED_EXT.test(f))
+        continue;
+      const path = join2(base, f);
+      if (statSync(path).isDirectory()) continue;
+      if (seedName(f) === "index") index = path;
+      else scripts.push({ name: seedName(f), path });
+    }
+    return { dir: { base, scripts, index } };
+  }
+  const file = SEED_EXT.test(base) ? base : `${base}.ts`;
+  return { file: existsSync2(file) ? file : base };
+}
+async function runSeedFile(db, path) {
+  if (!existsSync2(path)) throw new Error(`Seed file not found: ${path}`);
+  const mod = await makeJiti().import(path);
+  const fn = typeof mod.default === "function" ? mod.default : mod.seed;
+  if (typeof fn !== "function")
+    throw new Error(
+      `Seed "${relative(process.cwd(), path)}" must export a default function \`(db, ctx) => \u2026\`.`
+    );
+  const dir = dirname3(path);
+  const ctx = {
+    dir,
+    file: (name) => readFileSync2(resolve2(dir, name), "utf8")
+  };
+  await fn(db, ctx);
+}
+async function seed(db, config, opts = {}) {
+  const { dir, file } = locateSeeds(config);
+  if (!dir) {
+    if (opts.name)
+      throw new Error(
+        `--name needs a seed folder (database/seed/); found a single seed file instead.`
+      );
+    await runSeedFile(db, file);
+    return;
+  }
+  const { base, scripts, index } = dir;
+  const run2 = async (s) => {
+    console.log(style4.dim(`  \u2192 ${s.name}`));
+    await runSeedFile(db, s.path);
+  };
+  if (opts.name) {
+    const match = scripts.find((s) => s.name === opts.name);
+    if (!match)
+      throw new Error(
+        `No seed named "${opts.name}". Available: ${scripts.map((s) => s.name).join(", ") || "(none)"}.`
+      );
+    await run2(match);
+    return;
+  }
+  if (index && !opts.all) {
+    await runSeedFile(db, index);
+    return;
+  }
+  if (!scripts.length)
+    throw new Error(`No seeds found in ${relative(process.cwd(), base)}/.`);
+  for (const s of scripts) await run2(s);
+}
+
+// src/cli/portable-diff.ts
+import {
+  buildKindDiff as buildKindDiff2,
+  formatItems,
+  getDriver as getDriver4,
+  loadDefs as loadDefs3,
+  lowerSchema as lowerSchema3,
+  ok as ok2,
+  plural,
+  style as style5
+} from "@better-schemic/core";
+async function portableDiff(config, driverName, opts = {}) {
+  const driver = getDriver4(driverName);
+  const reg = driver.registry;
+  const { tables, defs } = await loadDefs3(config.schemaPath);
+  const desired = lowerSchema3(
+    reg,
+    driver.explode(tables, defs)
+  );
+  const conn = await driver.connect(config);
+  let live;
+  try {
+    live = await driver.introspectAll(
+      conn,
+      /* @__PURE__ */ new Set([config.migrationsTable, `${config.migrationsTable}_lock`])
+    );
+  } finally {
+    await closeQuietly(conn);
+  }
+  const diff = buildKindDiff2(reg, live, desired);
+  if (opts.json) {
+    console.log(
+      JSON.stringify({ driver: driverName, up: diff.up, down: diff.down })
+    );
+    return;
+  }
+  console.log(style5.dim(`  driver: ${driverName}`));
+  if (!diff.up.length) {
+    console.log(ok2("Schema is in sync with the target database."));
+    return;
+  }
+  const items = diff.items ?? [];
+  console.log(formatItems(items));
+  const n = (op) => items.filter((i) => i.op === op).length;
+  console.log(
+    style5.dim(
+      `
+${plural(items.length, "change")} \u2014 ${n("add")} added, ${n("change")} changed, ${n("remove")} removed.`
+    )
+  );
+}
+async function closeQuietly(conn) {
+  const close = conn?.close;
+  if (typeof close === "function") {
+    try {
+      await close.call(conn);
+    } catch {
+    }
+  }
+}
+
+// src/cli/index.ts
+var activeDriver = (config) => getDriver5(config.driver);
+async function withDb(opts, fn) {
+  const targets = await resolveTargets(opts);
+  for (const config of targets) {
+    if (targets.length > 1) console.log(style6.bold(`
+[${config.connection}]`));
+    const driver = getDriver5(config.driver);
+    const db = await driver.connect(config, opts);
+    try {
+      await fn(db, config);
+    } finally {
+      await driver.close(db);
+    }
+  }
+}
+var errMsg2 = (err) => err instanceof Error ? err.message : String(err);
+function formatDuplicates(dups, root) {
+  return [...dups].map(([name, files]) => {
+    const counts = /* @__PURE__ */ new Map();
+    for (const f of files) counts.set(f, (counts.get(f) ?? 0) + 1);
+    const label = [...counts].map(([f, n]) => {
+      const rel = relative2(root, f);
+      return n > 1 ? `${rel} (\xD7${n})` : rel;
+    }).join(", ");
+    return `${name} \u2014 ${label}`;
+  });
+}
+var duplicateHeader = (n) => `${plural2(n, "table")} defined more than once (last definition silently wins):`;
+function run(action) {
+  runAction(action);
+}
+async function promptTitle() {
+  if (!process.stdin.isTTY) return void 0;
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = (await rl.question("Migration title: ")).trim();
+    return answer || void 0;
+  } finally {
+    rl.close();
+  }
+}
+async function confirmPrompt(question) {
+  if (!process.stdin.isTTY) return false;
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
+  try {
+    const a = (await rl.question(`${question} [y/N] `)).trim().toLowerCase();
+    return a === "y" || a === "yes";
+  } finally {
+    rl.close();
+  }
+}
+function diffSummary(registry, diff, opts, pending) {
+  const summary = [];
+  if (!isEmptyDiff2(diff)) {
+    const kinds = summarizeKinds(registry, diff.items ?? []);
+    summary.push(
+      `${plural2(diff.up.length, "change")} ${opts.live ? "vs the live database" : "vs the snapshot"}${kinds ? ` \u2014 ${kinds}` : ""}.`
+    );
+  }
+  if (pending !== void 0)
+    summary.push(`${plural2(pending, "migration")} pending.`);
+  return summary.length ? `
+${style6.dim(summary.join("\n"))}` : "";
+}
+function reportDiff(registry, diff, opts, pending) {
+  console.log(
+    formatDiff(diff, { down: opts.down, full: opts.full, inline: opts.inline })
+  );
+  const summary = diffSummary(registry, diff, opts, pending);
+  if (summary) console.log(summary);
+}
+function watchLoop(config, task, cleanup) {
+  return new Promise(() => {
+    let timer;
+    let running = false;
+    let queued = false;
+    const fire = async () => {
+      if (running) {
+        queued = true;
+        return;
+      }
+      running = true;
+      console.log(style6.dim(`
+\u2014 ${(/* @__PURE__ */ new Date()).toLocaleTimeString()} \u2014`));
+      try {
+        await task();
+      } catch (err) {
+        console.error(fail3(errMsg2(err)));
+      }
+      running = false;
+      if (queued) {
+        queued = false;
+        void fire();
+      }
+    };
+    const watcher = fsWatch(
+      config.schemaPath,
+      { recursive: !config.schemaIsFile },
+      () => {
+        clearTimeout(timer);
+        timer = setTimeout(() => void fire(), 150);
+      }
+    );
+    console.log(
+      style6.dim(
+        `Watching ${relative2(config.root, config.schemaPath)} for changes \u2014 ctrl-c to stop.`
+      )
+    );
+    void fire();
+    const stop = () => {
+      watcher.close();
+      clearTimeout(timer);
+      Promise.resolve(cleanup?.()).finally(() => process.exit(0));
+    };
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+  });
+}
+var configFlag = (cmd) => cmd.option("-c, --config <path>", "path to better-schemic.config.ts");
+var dbFlags = (cmd) => configFlag(cmd).option(
+  "--connection <name>",
+  "target a specific connection (or <name>:<key> within a collection)"
+).option("--all", "run against every connection (collections fanned out)").option(
+  "--arg <key=value>",
+  "value passed to connection resolvers (repeatable)",
+  collectArg,
+  []
+).option(
+  "--args <json>",
+  "resolver args as one JSON object (--arg k=v merges over it)"
+).option("--url <url>", "override the connection endpoint").option("--namespace <ns>", "override the namespace").option("--database <db>", "override the database").option("--username <user>", "override the auth username").option("--password <pass>", "override the auth password").addOption(
+  new Option("--auth-level <level>", "auth level").choices([
+    "root",
+    "namespace",
+    "database"
+  ])
+);
+var program = new Command();
+program.name("better-schemic").description(
+  "Schema-as-code migrations for any database \u2014 generate DDL, diff, and migrate via drivers"
+).version(version).showHelpAfterError("(run `better-schemic --help` for usage)").addHelpText(
+  "after",
+  `
+Examples:
+  $ better-schemic init                 scaffold database/ (schemas + migrations) + config
+  $ better-schemic gen add_users        create a migration from schema changes
+  $ better-schemic migrate              apply pending migrations
+  $ better-schemic push --watch         keep the database in sync while you edit
+  $ better-schemic diff --live          show how the schema differs from the live database
+`
+);
+program.configureHelp({
+  visibleOptions(cmd) {
+    const opts = Help.prototype.visibleOptions.call(this, cmd);
+    const negated = new Set(
+      opts.filter((o) => o.negate).map((o) => o.attributeName())
+    );
+    this._collapsible = new Set(
+      [...negated].filter(
+        (n) => opts.some((o) => !o.negate && o.attributeName() === n)
+      )
+    );
+    return opts.filter(
+      (o) => !(o.negate && this._collapsible?.has(o.attributeName()))
+    );
+  },
+  optionTerm(option) {
+    const term = Help.prototype.optionTerm.call(this, option);
+    if (option.negate) return term.replace("--no-", "--[no-]");
+    if (this._collapsible?.has(option.attributeName()))
+      return term.replace(`--${option.name()}`, `--[no-]${option.name()}`);
+    return term;
+  }
+});
+program.command("init").description("Scaffold database/ (schemas + migrations) and a config file").option(
+  "--driver <name>",
+  "database driver to scaffold for (default surrealdb)"
+).action((opts) => {
+  run(async () => {
+    const name = opts.driver ?? "surrealdb";
+    try {
+      await ensureDriver(name);
+    } catch (e) {
+      if (process.env.BETTER_SCHEMIC_NO_BOOTSTRAP ?? process.env.SCHEMIC_NO_BOOTSTRAP)
+        throw e;
+      console.log(
+        style6.dim(
+          "This project isn't set up for Better-schemic yet \u2014 bootstrapping with create-better-schemic\u2026\n"
+        )
+      );
+      const runner = process.versions.bun ? ["bun", "x"] : ["npx", "-y"];
+      const r = spawnSync(
+        runner[0],
+        [...runner.slice(1), "create-better-schemic", ".", "--driver", name],
+        { stdio: "inherit", cwd: process.cwd() }
+      );
+      process.exit(r.status ?? 1);
+    }
+    const { created, skipped } = init(process.cwd(), getDriver5(name));
+    for (const f of created) console.log(`  ${style6.green("+")} ${f}`);
+    for (const f of skipped)
+      console.log(style6.dim(`  \xB7 ${f} (exists, skipped)`));
+    console.log(
+      created.length ? `
+${ok3("Initialized. Edit database/schema, then run `better-schemic gen`.")}` : "\nNothing to do \u2014 already initialized."
+    );
+  });
+});
+kindFlags(
+  dbFlags(
+    program.command("diff").description("Show pending schema changes without writing a migration")
+  )
+).option("--down", "also show the rollback (down) statements").option("--live", "diff against the live database instead of the snapshot").option("--ts", "show the change as TypeScript schema instead of DDL").option("--watch", "re-run on schema changes").option("--full", "show the full schema SQL, not just the changed parts").option(
+  "-p, --patch",
+  "output a unified diff (e.g. to pipe to a diff viewer)"
+).option(
+  "--pager [cmd]",
+  "page through your git diff viewer (or <cmd>); off by default"
+).option(
+  "--inline",
+  "render changes as an inline word-diff instead of separate -/+ lines"
+).option("--json", "output the diff as JSON").option(
+  "--driver <name>",
+  "target database driver (default from config, or 'surreal')"
+).action(
+  (opts) => {
+    run(async () => {
+      const config = await resolveOne(opts);
+      const driverName = opts.driver ?? config.driver ?? "surrealdb";
+      await ensureDriver(driverName);
+      const driver = getDriver5(driverName);
+      const diffLive = driver.diffLive;
+      if (!diffLive) {
+        await portableDiff(config, driverName, { json: opts.json });
+        return;
+      }
+      const filter = parseFilter2(opts);
+      const pager = opts.watch || opts.pager === void 0 || opts.pager === false ? void 0 : typeof opts.pager === "string" ? opts.pager : resolvePager();
+      const emit = async (diff, pending) => {
+        if (opts.json) {
+          console.log(
+            JSON.stringify({ up: diff.up, down: diff.down, pending })
+          );
+        } else if ((opts.patch || pager) && !isEmptyDiff2(diff)) {
+          const patch = formatPatch(diff);
+          if (pager) await pipeThroughPager(pager, patch);
+          else process.stdout.write(patch);
+          const summary = diffSummary(driver.registry, diff, opts, pending);
+          if (summary) console.log(summary);
+        } else {
+          reportDiff(driver.registry, diff, opts, pending);
+        }
+      };
+      const persistent = opts.watch && opts.live ? await driver.connect(config, opts) : void 0;
+      const once = async () => {
+        if (opts.ts) {
+          const loc = await existingTables(config.schemaPath);
+          const fileFor = (kind, name) => {
+            const abs = kind === "table" ? loc.get(name) : void 0;
+            return abs ? relative2(config.root, abs) : relative2(
+              config.root,
+              join3(
+                config.schemaPath,
+                driver.registry.display(kind).folder,
+                `${name}.ts`
+              )
+            );
+          };
+          const single = config.schemaIsFile ? relative2(config.root, config.schemaPath) : void 0;
+          const showTsDiff = async (cur, des, matchMsg) => {
+            if (opts.json) {
+              console.log(
+                JSON.stringify({
+                  current: Object.fromEntries(cur),
+                  desired: Object.fromEntries(des)
+                })
+              );
+              return;
+            }
+            const files = [.../* @__PURE__ */ new Set([...cur.keys(), ...des.keys()])].sort();
+            const changed = files.filter(
+              (f) => (cur.get(f) ?? "") !== (des.get(f) ?? "")
+            );
+            if (!changed.length) {
+              console.log(ok3(matchMsg));
+            } else if (pager || opts.patch) {
+              const patch = changed.map(
+                (f) => unifiedDiff(cur.get(f) ?? "", des.get(f) ?? "", f)
+              ).join("");
+              if (pager) await pipeThroughPager(pager, patch);
+              else process.stdout.write(patch);
+            } else {
+              console.log(
+                changed.map(
+                  (f) => `${style6.bold(f)}
+${lineDiff(cur.get(f) ?? "", des.get(f) ?? "")}`
+                ).join("\n\n")
+              );
+            }
+          };
+          if (opts.live) {
+            if (!driver.diffTsLive)
+              throw new Error(
+                `the "${driverName}" driver does not support \`diff --ts --live\`.`
+              );
+            const db = persistent ?? await driver.connect(config, opts);
+            try {
+              const { current, desired } = await driver.diffTsLive(
+                db,
+                config,
+                filter,
+                fileFor,
+                single
+              );
+              await showTsDiff(
+                current,
+                desired,
+                "Schema matches the live database."
+              );
+            } finally {
+              if (!persistent) await driver.close(db);
+            }
+          } else {
+            if (!driver.renderSchema)
+              throw new Error(
+                `the "${driverName}" driver does not support \`diff --ts\`.`
+              );
+            const prev = readSnapshot3(config.metaDir);
+            const prevObjects = snapshotObjects3(prev.schema);
+            const { tables, defs } = await loadDefs4(config.schemaPath);
+            const desiredObjects = lowerSchema4(
+              driver.registry,
+              driver.explode(tables, defs)
+            );
+            await showTsDiff(
+              driver.renderSchema(prevObjects, filter, fileFor, single),
+              driver.renderSchema(desiredObjects, filter, fileFor, single),
+              prevObjects.length ? "Schema matches the snapshot." : "No schema to render."
+            );
+          }
+          return;
+        }
+        if (opts.live) {
+          const db = persistent ?? await driver.connect(config, opts);
+          try {
+            const diff = await diffLive(db, config, filter);
+            const pending = (await status(db, config)).filter(
+              (r) => !r.applied
+            ).length;
+            await emit(diff, pending);
+          } finally {
+            if (!persistent) await driver.close(db);
+          }
+        } else {
+          await emit((await planMigration(config, filter)).diff);
+        }
+      };
+      if (!opts.watch) return once();
+      await watchLoop(
+        config,
+        once,
+        persistent ? () => driver.close(persistent) : void 0
+      );
+    });
+  }
+);
+var genAction = (name, opts) => {
+  run(async () => {
+    const config = await resolveOne(opts);
+    const filter = parseFilter2(opts);
+    let squashed = null;
+    if (opts.baseline) {
+      const existing = listMigrations2(
+        config.migrationsDir,
+        activeDriver(config).migrations?.extension ?? ".surql"
+      );
+      if (existing.length) {
+        const migDir = relative2(config.root, config.migrationsDir);
+        const proceed = opts.force || await confirmPrompt(
+          `Replace ${plural2(existing.length, "migration")} in ${migDir} with a single baseline?`
+        );
+        if (!proceed) {
+          throw new Error(
+            `${plural2(existing.length, "migration")} already exist in ${migDir} \u2014 a baseline would re-define objects they already created.
+  Re-run \`better-schemic gen --baseline --force\` to replace them with one fresh baseline.`
+          );
+        }
+        squashed = clearMigrationFiles(config);
+      }
+    }
+    const plan = await planMigration(config, filter, {
+      baseline: opts.baseline
+    });
+    if (isEmptyDiff2(plan.diff)) {
+      console.log(ok3("No schema changes \u2014 nothing to generate."));
+      return;
+    }
+    const kinds = summarizeKinds(
+      activeDriver(config).registry,
+      plan.diff.items ?? []
+    );
+    console.log(
+      `${plural2(plan.diff.up.length, "change")}${kinds ? ` \u2014 ${kinds}` : ""}.`
+    );
+    const body = renderMigrationPreview(config, plan.diff).replace(/\n+$/, "").split("\n").map((line) => `  ${line}`).join("\n");
+    console.log(`
+${style6.dim(body)}
+`);
+    const title = name ?? (opts.baseline ? "baseline" : opts.yes ? void 0 : await promptTitle());
+    const prepared = prepareMigration(config, plan, title);
+    if (!prepared) {
+      console.log(ok3("No schema changes \u2014 nothing to generate."));
+      return;
+    }
+    const res = commitMigration(config, prepared);
+    console.log(
+      `${ok3(res.file ?? "migration written")}  ${style6.dim(`(+${res.up} up / ${res.down} down)`)}`
+    );
+    if (squashed) {
+      console.log(
+        style6.dim(`  replaced ${plural2(squashed.length, "migration")}.`)
+      );
+      try {
+        const driver = activeDriver(config);
+        const diffLive = driver.diffLive;
+        if (!diffLive)
+          throw new Error(
+            `the "${config.driver ?? "surrealdb"}" driver does not support live reconcile`
+          );
+        const db = await driver.connect(config, opts);
+        try {
+          const drift = !isEmptyDiff2(await diffLive(db, config, filter));
+          const state = await reconcileBaseline(db, config, prepared, drift);
+          console.log(
+            style6.dim(
+              state === "applied" ? "  database matched the schema \u2014 baseline recorded as applied." : "  database differs from the schema \u2014 baseline left pending; run `better-schemic migrate`."
+            )
+          );
+        } finally {
+          await driver.close(db);
+        }
+      } catch (e) {
+        console.log(
+          style6.dim(
+            `  database not reconciled (${errMsg2(e)}) \u2014 baseline is pending; run \`better-schemic migrate\` to apply it.`
+          )
+        );
+      }
+    }
+  });
+};
+var addGenCommand = (cmd) => {
+  kindFlags(dbFlags(cmd)).option("-y, --yes", "use the given/default name without prompting").option(
+    "--baseline",
+    "regenerate one fresh baseline from an empty snapshot (replaces existing migrations)"
+  ).option(
+    "--force",
+    "with --baseline, replace existing migrations without confirmation"
+  ).action(genAction);
+};
+addGenCommand(
+  program.command("gen [name]").description("Diff schemas, preview the migration script, and write it")
+);
+addGenCommand(program.command("generate [name]", { hidden: true }));
+var snapshot = program.command("snapshot").description(
+  "Manage the migration snapshot (what `better-schemic gen`/`better-schemic diff` compare against)"
+);
+configFlag(
+  snapshot.command("reset").description(
+    "Clear the snapshot \u2014 the next `better-schemic gen` baselines the full schema"
+  )
+).action((opts) => {
+  run(async () => {
+    const config = await resolveOne(opts);
+    writeSnapshot2(config.metaDir, EMPTY_STORED2);
+    console.log(ok3("Snapshot cleared."));
+    const existing = listMigrations2(
+      config.migrationsDir,
+      activeDriver(config).migrations?.extension ?? ".surql"
+    );
+    if (existing.length) {
+      console.log(
+        style6.dim(
+          `  ${plural2(existing.length, "migration")} still on disk \u2014 run \`better-schemic gen --baseline --force\` to replace them with one fresh baseline. (A plain \`better-schemic gen\` would add a baseline alongside them.)`
+        )
+      );
+    } else {
+      console.log(
+        style6.dim(
+          "  The next `better-schemic gen` will baseline the full schema."
+        )
+      );
+    }
+  });
+});
+dbFlags(
+  program.command("migrate [count]").alias("up").description(
+    "Apply pending migrations (all, the next N, or up to --to <tag>)"
+  ).option("--to <tag>", "apply up to and including this migration")
+).action((count, opts) => {
+  run(
+    () => withDb(opts, async (db, config) => {
+      const n = count === void 0 ? void 0 : Math.max(1, Number.parseInt(count, 10) || 1);
+      const { applied } = await migrate(db, config, { count: n, to: opts.to });
+      if (!applied.length) {
+        console.log(ok3("Up to date \u2014 no pending migrations."));
+        return;
+      }
+      for (const e of applied) console.log(`  ${style6.green("\u2191")} ${e.tag}`);
+      console.log(`
+${ok3(`Applied ${plural2(applied.length, "migration")}.`)}`);
+    })
+  );
+});
+dbFlags(
+  program.command("status").description("Show applied vs pending migrations")
+).option("--json", "output the status as JSON").action((opts) => {
+  run(
+    () => withDb(opts, async (db, config) => {
+      const rows = await status(db, config);
+      if (opts.json) {
+        console.log(JSON.stringify(rows));
+        return;
+      }
+      if (!rows.length) {
+        console.log("No migrations yet. Run `better-schemic gen`.");
+        return;
+      }
+      for (const r of rows) {
+        if (r.missing) {
+          console.log(
+            `  ${style6.yellow("\u26A0 missing")}  ${r.tag} ${style6.dim("(applied in the DB, file deleted)")}`
+          );
+        } else if (r.drift) {
+          console.log(
+            `  ${style6.yellow("\u26A0 drift")}    ${r.tag} ${style6.dim("(file changed after apply)")}`
+          );
+        } else if (r.applied) {
+          console.log(`  ${style6.green("\u2713 applied")}  ${r.tag}`);
+        } else {
+          console.log(style6.dim(`  \xB7 pending  ${r.tag}`));
+        }
+      }
+      const pending = rows.filter((r) => !r.applied).length;
+      const drifted = rows.filter((r) => r.drift).length;
+      const missing = rows.filter((r) => r.missing).length;
+      const parts = [plural2(rows.length, "migration"), `${pending} pending`];
+      if (drifted) parts.push(`${drifted} drifted`);
+      if (missing) parts.push(`${missing} missing`);
+      console.log(`
+${style6.dim(`${parts.join(", ")}.`)}`);
+      if (missing) {
+        console.log(
+          style6.dim(
+            "  Missing migrations were applied but their files are gone (e.g. after removing migrations or `snapshot reset`)."
+          )
+        );
+      }
+    })
+  );
+});
+dbFlags(
+  program.command("check").description(
+    "Validate schemas, then replay migrations to confirm they reproduce the schema"
+  ).option(
+    "--schema",
+    "validate the schema only \u2014 skip the migration replay (no database)"
+  )
+).action((opts) => {
+  run(async () => {
+    const config = await resolveOne(opts);
+    const driver = activeDriver(config);
+    const dups = await duplicateTables(config.schemaPath);
+    if (dups.size) {
+      const lines = formatDuplicates(dups, config.root).map((l) => `  ${l}`);
+      throw new Error(`${duplicateHeader(dups.size)}
+${lines.join("\n")}`);
+    }
+    const { tables, defs } = await loadDefs4(config.schemaPath);
+    const kinds = summarizeKinds(
+      driver.registry,
+      lowerSchema4(driver.registry, driver.explode(tables, defs))
+    );
+    console.log(ok3(`Schemas valid${kinds ? ` \u2014 ${kinds}` : " (no objects)"}.`));
+    if (opts.schema) return;
+    if (!driver.checkReplay) {
+      throw new Error(
+        `the "${config.driver ?? "surrealdb"}" driver does not support migration replay \u2014 run \`better-schemic check --schema\` to validate the schema only.`
+      );
+    }
+    const diff = await driver.checkReplay(
+      config,
+      opts,
+      parseFilter2({}),
+      (m) => console.log(style6.dim(m))
+    );
+    if (isEmptyDiff2(diff)) {
+      console.log(ok3("Migrations reproduce the schema."));
+      return;
+    }
+    console.log(
+      `
+${fail3("Drift \u2014 migrations do not reproduce the schema:")}
+`
+    );
+    console.log(formatDiff(diff, {}));
+    console.log(
+      `
+${style6.dim(`${summarizeKinds(driver.registry, diff.items ?? [])} differ. \`better-schemic gen\` writes a migration to reconcile.`)}`
+    );
+    process.exitCode = 1;
+  });
+});
+dbFlags(
+  program.command("doctor").description("Print resolved config and test the connection")
+).action((opts) => {
+  run(async () => {
+    const config = await resolveOne(opts);
+    const row = (k, v) => console.log(style6.dim(`  ${k.padEnd(11)} ${v}`));
+    console.log(style6.bold("Project"));
+    row("root", config.root);
+    row("connection", `${config.connection} (${config.driver})`);
+    row("migrations", relative2(config.root, config.migrationsDir));
+    console.log(style6.bold("\nSchema"));
+    row(
+      "source",
+      `${relative2(config.root, config.schemaPath)} (${config.schemaIsFile ? "file" : "directory"})`
+    );
+    try {
+      const defs = await loadSchemas(config.schemaPath);
+      row(
+        "tables",
+        defs.length ? `${plural2(defs.length, "table")} \u2014 ${defs.map((t) => t.name).join(", ")}` : "(none found)"
+      );
+      const dups = await duplicateTables(config.schemaPath);
+      if (dups.size) {
+        console.log(`  ${fail3(duplicateHeader(dups.size))}`);
+        for (const line of formatDuplicates(dups, config.root))
+          console.log(style6.dim(`    ${line}`));
+        process.exitCode = 1;
+      }
+    } catch (e) {
+      console.log(`  ${fail3(e instanceof Error ? e.message : String(e))}`);
+    }
+    console.log(style6.bold("\nConnection"));
+    const secret = /pass|secret|token|key/i;
+    const params = Object.entries(config.params);
+    if (params.length) {
+      for (const [k, v] of params)
+        row(k, secret.test(k) ? "***" : String(v ?? ""));
+    } else {
+      row("params", "(none)");
+    }
+    console.log(style6.bold("\nVersions"));
+    row("@better-schemic/core", program.version() ?? "?");
+    row("node", process.version);
+    console.log(style6.bold("\nStatus"));
+    try {
+      const driver = activeDriver(config);
+      const db = await driver.connect(config, opts);
+      const info = driver.serverInfo ? await driver.serverInfo(db) : config.driver ?? "surrealdb";
+      console.log(`  ${ok3(`connected \u2014 ${info}`)}`);
+      await driver.close(db);
+    } catch (e) {
+      console.log(`  ${fail3(e instanceof Error ? e.message : String(e))}`);
+      process.exitCode = 1;
+    }
+  });
+});
+dbFlags(
+  program.command("rollback [count]").alias("down").description("Roll back applied migrations (last N, or back to --to <tag>)").option("--to <tag>", "roll back everything applied after this migration")
+).action((count, opts) => {
+  run(
+    () => withDb(opts, async (db, config) => {
+      const reverted = await rollback(db, config, {
+        to: opts.to,
+        count: opts.to || count === void 0 ? void 0 : Math.max(1, Number.parseInt(count, 10) || 1)
+      });
+      if (!reverted.length) {
+        console.log(ok3("Nothing to roll back."));
+        return;
+      }
+      for (const e of reverted) console.log(`  ${style6.yellow("\u2193")} ${e.tag}`);
+      console.log(
+        `
+${ok3(`Rolled back ${plural2(reverted.length, "migration")}.`)}`
+      );
+    })
+  );
+});
+configFlag(
+  program.command("new <kind> <name>").description(
+    "Scaffold a new schema file for an entity, e.g. `sc new table user`"
+  )
+).action((kind, name, opts) => {
+  run(async () => {
+    const config = await resolveOne(opts);
+    const driver = activeDriver(config);
+    if (!driver.scaffoldEntity)
+      throw new Error(`the "${config.driver}" driver can't scaffold entities.`);
+    if (config.schemaIsFile)
+      throw new Error(
+        "`better-schemic new` needs a schema directory \u2014 your schema is a single file."
+      );
+    const content = driver.scaffoldEntity(kind, name);
+    const target = join3(
+      config.schemaPath,
+      driver.registry.display(kind).folder,
+      `${name}.ts`
+    );
+    if (existsSync3(target))
+      throw new Error(`${relative2(config.root, target)} already exists.`);
+    mkdirSync3(dirname4(target), { recursive: true });
+    writeFileSync3(target, content);
+    console.log(
+      `${ok3(relative2(config.root, target))}  ${style6.dim("\u2014 author its fields, then `better-schemic gen`")}`
+    );
+  });
+});
+dbFlags(
+  program.command("unlock").description("Clear a stale migration lock")
+).action((opts) => {
+  run(
+    () => withDb(opts, async (db, config) => {
+      await unlock(db, config);
+      console.log(ok3("Migration lock cleared."));
+    })
+  );
+});
+kindFlags(
+  dbFlags(
+    program.command("push").alias("sync").description(
+      "Reconcile the live database with your schema (no migration files)"
+    ).option("--no-prune", "keep objects that were removed from the schema").option("--dry-run", "preview the changes without applying them").option("--watch", "re-sync on schema changes")
+  )
+).action(
+  (opts) => {
+    run(async () => {
+      const config = await resolveOne(opts);
+      const driver = activeDriver(config);
+      const filter = parseFilter2(opts);
+      const diffLive = driver.diffLive;
+      const syncPlan = driver.syncPlan;
+      if (!diffLive || !syncPlan)
+        throw new Error(
+          `the "${config.driver ?? "surrealdb"}" driver does not support \`push\`.`
+        );
+      const once = async (db2) => {
+        const diff = await diffLive(db2, config, filter);
+        const stmts = syncPlan(diff, opts.prune);
+        if (!stmts.length) {
+          console.log(ok3("Database already matches the schema."));
+          return;
+        }
+        const items = (diff.items ?? []).filter(
+          (it) => opts.prune !== false || it.op !== "remove"
+        );
+        console.log(formatItems2(items));
+        const kinds = summarizeKinds(driver.registry, items);
+        if (opts.dryRun) {
+          console.log(
+            `
+${style6.dim(`${plural2(stmts.length, "change")}${kinds ? ` \u2014 ${kinds}` : ""} \u2014 run \`better-schemic push\` to apply.`)}`
+          );
+          return;
+        }
+        await driver.apply(db2, stmts);
+        const pruned = opts.prune === false ? 0 : (diff.items ?? []).filter((it) => it.op === "remove").length;
+        console.log(
+          `
+${ok3(`synced ${plural2(stmts.length - pruned, "object")}${pruned ? `, pruned ${pruned}` : ""}${kinds ? ` (${kinds})` : ""}.`)}`
+        );
+      };
+      if (!opts.watch) {
+        await withDb(opts, (db2) => once(db2));
+        return;
+      }
+      const db = await driver.connect(config, opts);
+      await watchLoop(
+        config,
+        () => once(db),
+        () => driver.close(db)
+      );
+    });
+  }
+);
+dbFlags(
+  program.command("seed [name]").description(
+    "Run the project's seed(s): a named seed, --all (every seed), or (no arg) index.ts / every seed"
+  )
+  // NOTE: `--all` comes from dbFlags (every connection) and doubles as "every seed" here — do NOT add
+  // a second `--all` option (commander throws a conflicting-flag error at construction).
+).action((name, opts) => {
+  run(
+    () => withDb(opts, async (db, config) => {
+      await seed(db, config, { name, all: opts.all });
+      console.log(ok3("Seed complete."));
+    })
+  );
+});
+function printPullPlan(plan) {
+  for (const f of plan.files) {
+    if (f.action === "unchanged") continue;
+    console.log(`
+${actionLabel(f.action)} ${style6.bold(f.rel)}`);
+    if (f.action === "delete") {
+      console.log(
+        style6.dim(
+          `  whole file removed \u2014 ${f.localOnly.objects.join(", ")} not in the database`
+        )
+      );
+      continue;
+    }
+    console.log(
+      lineDiff(f.before, f.after).split("\n").map((l) => `  ${l}`).join("\n")
+    );
+  }
+}
+function printLocalOnly(files) {
+  console.log(`
+${style6.yellow("! local-only schema, not in the database:")}`);
+  for (const f of files) {
+    for (const fld of f.localOnly.fields)
+      console.log(
+        style6.dim(`    ${f.rel}: ${fld.exportName} \u2192 ${fld.fields.join(", ")}`)
+      );
+    for (const obj of f.localOnly.objects)
+      console.log(style6.dim(`    ${f.rel}: ${obj} (whole definition)`));
+  }
+  console.log(style6.dim("  keep with --merge, or drop with --discard."));
+}
+async function pullPass(db, config, opts, watch) {
+  const driver = activeDriver(config);
+  if (!driver.planPull)
+    throw new Error(
+      `the "${config.driver ?? "surrealdb"}" driver does not support \`pull\`.`
+    );
+  const plan = await driver.planPull(db, config, {
+    filter: parseFilter2(opts),
+    keepLocal: opts.merge
+  });
+  const changed = plan.files.filter((f) => f.action !== "unchanged");
+  const atRisk = opts.merge ? [] : plan.files.filter(
+    (f) => f.localOnly.fields.length || f.localOnly.objects.length
+  );
+  if (!changed.length && !atRisk.length) return false;
+  printPullPlan(plan);
+  if (!opts.write) {
+    if (changed.length)
+      console.log(
+        `
+${style6.dim(`${plural2(changed.length, "file")} would change \u2014 run \`better-schemic pull --write\` to apply.`)}`
+      );
+    if (atRisk.length) printLocalOnly(atRisk);
+    return true;
+  }
+  if (atRisk.length && !opts.discard) {
+    printLocalOnly(atRisk);
+    const msg = "pull would overwrite local-only schema \u2014 re-run with --merge to keep it or --discard to mirror the database.";
+    if (!watch) throw new Error(msg);
+    console.error(fail3(msg));
+    return true;
+  }
+  const written = applyPull(plan);
+  const base = await baseline(db, config);
+  const removed = plan.files.filter((f) => f.action === "delete").length;
+  const kept = opts.merge ? [] : plan.files.filter(
+    (f) => f.action === "unchanged" && f.localOnly.objects.length
+  );
+  console.log(
+    `
+${ok3(`Pulled ${plural2(written.length, "file")} from the database${removed ? ` (${removed} removed)` : ""}.`)}`
+  );
+  if (base.created)
+    console.log(
+      style6.dim(
+        `  baseline ${base.tag} recorded (snapshot synced, marked applied).`
+      )
+    );
+  if (kept.length)
+    console.log(
+      style6.dim(
+        `  ${plural2(kept.length, "file")} with local-only entities mixed with other code left in place \u2014 remove those entities by hand.`
+      )
+    );
+  return true;
+}
+function pullPollLoop(config, db, intervalMs, opts) {
+  return new Promise(() => {
+    const driver = activeDriver(config);
+    console.log(
+      style6.dim(
+        `Polling ${config.connection ?? "the database"} every ${intervalMs / 1e3}s \u2014 ctrl-c to stop.`
+      )
+    );
+    let stopped = false;
+    const stop = () => {
+      stopped = true;
+      Promise.resolve(driver.close(db)).finally(() => process.exit(0));
+    };
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+    const tick = async () => {
+      if (stopped) return;
+      try {
+        const printed = await pullPass(db, config, opts, true);
+        if (!printed)
+          process.stdout.write(
+            style6.dim(`\r\xB7 ${(/* @__PURE__ */ new Date()).toLocaleTimeString()}  in sync   `)
+          );
+      } catch (err) {
+        console.error(`
+${fail3(errMsg2(err))}`);
+      }
+      if (!stopped) setTimeout(() => void tick(), intervalMs);
+    };
+    void tick();
+  });
+}
+kindFlags(
+  dbFlags(
+    program.command("pull").description("Generate/update Zod schema files from the live database").option("--write", "apply the changes (default: preview only)").option(
+      "--merge",
+      "keep local-only fields/objects (default: mirror the DB)"
+    ).option(
+      "--discard",
+      "drop local-only fields/objects to mirror the DB exactly"
+    ).option("--watch", "poll the live DB and re-pull as it changes").option(
+      "--interval <seconds>",
+      "poll interval in seconds for --watch (default: 2)"
+    )
+  )
+).action(
+  (opts) => {
+    run(async () => {
+      if (opts.watch) {
+        const config = await resolveOne(opts);
+        const driver = activeDriver(config);
+        if (!driver.planPull)
+          throw new Error(
+            `the "${config.driver ?? "surrealdb"}" driver does not support \`pull\`.`
+          );
+        const intervalMs = Math.max(500, (Number(opts.interval) || 2) * 1e3);
+        const db = await driver.connect(config, opts);
+        await pullPollLoop(config, db, intervalMs, opts);
+        return;
+      }
+      await withDb(opts, async (db, config) => {
+        if (!await pullPass(db, config, opts, false))
+          console.log(ok3("Schema files already match the database."));
+      });
+    });
+  }
+);
+async function bootstrap() {
+  await registerDriverCommands(program).catch(() => {
+  });
+  if (process.argv.length <= 2) {
+    program.outputHelp();
+    process.exit(0);
+  }
+  await program.parseAsync();
+}
+bootstrap();