@umec/core 0.1.0-alpha.0 → 0.1.0-alpha.10

package/dist/cli.js

@@ -0,0 +1,823 @@
+#!/usr/bin/env node
+import "./chunk-CYKUAS3D.js";
+import {
+  CORE_TABLES,
+  TRACKING_TABLES_SQL,
+  classifyDrift,
+  introspectSnapshot
+} from "./chunk-PNICEHSO.js";
+import {
+  currentSchemaVersion,
+  findPackageRoot,
+  listCoreMigrations,
+  loadSnapshotJson
+} from "./chunk-T2PO3YLZ.js";
+
+// src/cli/index.ts
+import { readFileSync as readFileSync5 } from "fs";
+import { join as join5 } from "path";
+
+// src/cli/doctor.ts
+import { existsSync } from "fs";
+import { join } from "path";
+
+// schema/upgrades/v2-to-v6.ts
+var UPGRADE_PAGE_SIZE = 500;
+var V6_ORDERS_DDL = `CREATE TABLE orders_new (
+  id                 TEXT PRIMARY KEY,
+  email              TEXT NOT NULL,
+  name               TEXT,
+  phone              TEXT,
+  items_json         TEXT NOT NULL,
+  amount             INTEGER NOT NULL,
+  shipping           INTEGER,
+  address_json       TEXT,
+  payment_intent     TEXT,
+  custom_fields_json TEXT,
+  status             TEXT NOT NULL DEFAULT 'pending',
+  run_id             TEXT,
+  email_status       TEXT CHECK (email_status IN ('sent', 'failed')),
+  created_at         INTEGER NOT NULL,
+  shipped_at         INTEGER,
+  tracking_number    TEXT,
+  carrier            TEXT CHECK (carrier IN ('yamato', 'sagawa', 'japanpost', 'other') OR carrier IS NULL)
+)`;
+function asString(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+function asNullableString(value) {
+  return typeof value === "string" ? value : null;
+}
+function asNumber(value, fallback = 0) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function asNullableNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+async function detectLegacyOrdersPk(db) {
+  const columns = await db.all("PRAGMA table_info(orders)");
+  if (columns.length === 0) return false;
+  const eventId = columns.find((column) => column.name === "event_id");
+  return eventId != null && eventId.pk === 1;
+}
+function mapLegacyOrder(row) {
+  const sessionId = asNullableString(row.session_id);
+  const eventId = asString(row.event_id);
+  return {
+    id: sessionId && sessionId.length > 0 ? sessionId : eventId,
+    email: asString(row.customer_email ?? row.email),
+    name: asNullableString(row.name),
+    phone: asNullableString(row.phone),
+    items_json: asNullableString(row.items_json) ?? "[]",
+    amount: asNumber(row.amount_total ?? row.amount),
+    shipping: asNullableNumber(row.shipping),
+    address_json: asNullableString(row.address_json),
+    payment_intent: asNullableString(row.payment_intent),
+    custom_fields_json: asNullableString(row.custom_fields_json),
+    status: asNullableString(row.status) ?? "pending",
+    run_id: asNullableString(row.run_id),
+    email_status: asNullableString(row.email_status),
+    created_at: asNumber(row.created_at),
+    shipped_at: asNullableNumber(row.shipped_at),
+    tracking_number: asNullableString(row.tracking_number),
+    carrier: asNullableString(row.carrier)
+  };
+}
+async function applyV2toV6(db) {
+  if (!await detectLegacyOrdersPk(db)) {
+    throw new Error("v2-to-v6: orders.event_id primary key not found; refuse to rebuild");
+  }
+  await db.exec("DROP TABLE IF EXISTS orders_new");
+  await db.exec(V6_ORDERS_DDL);
+  let cursor = null;
+  for (; ; ) {
+    const pageSql = cursor ? "SELECT * FROM orders WHERE event_id > ? ORDER BY event_id LIMIT ?" : "SELECT * FROM orders ORDER BY event_id LIMIT ?";
+    const pageParams = cursor ? [cursor, UPGRADE_PAGE_SIZE] : [UPGRADE_PAGE_SIZE];
+    const rows = await db.all(pageSql, pageParams);
+    if (rows.length === 0) break;
+    for (const row of rows) {
+      const mapped = mapLegacyOrder(row);
+      await db.run(
+        `INSERT INTO orders_new (
+          id, email, name, phone, items_json, amount, shipping, address_json,
+          payment_intent, custom_fields_json, status, run_id, email_status,
+          created_at, shipped_at, tracking_number, carrier
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        [
+          mapped.id,
+          mapped.email,
+          mapped.name,
+          mapped.phone,
+          mapped.items_json,
+          mapped.amount,
+          mapped.shipping,
+          mapped.address_json,
+          mapped.payment_intent,
+          mapped.custom_fields_json,
+          mapped.status,
+          mapped.run_id,
+          mapped.email_status,
+          mapped.created_at,
+          mapped.shipped_at,
+          mapped.tracking_number,
+          mapped.carrier
+        ]
+      );
+    }
+    const last = rows[rows.length - 1];
+    if (!last) break;
+    cursor = last.event_id;
+    if (rows.length < UPGRADE_PAGE_SIZE) break;
+  }
+  const oldCount = await db.first("SELECT COUNT(*) AS n FROM orders");
+  const newCount = await db.first("SELECT COUNT(*) AS n FROM orders_new");
+  const expected = oldCount?.n ?? -1;
+  const copied = newCount?.n ?? -2;
+  if (expected !== copied) {
+    throw new Error(
+      `v2-to-v6: COUNT mismatch orders=${expected} orders_new=${copied}. DROP skipped. Restore from Time Travel bookmark.`
+    );
+  }
+  await db.exec("DROP TABLE orders");
+  await db.exec("ALTER TABLE orders_new RENAME TO orders");
+  await db.exec("CREATE INDEX IF NOT EXISTS orders_payment_intent_idx ON orders(payment_intent)");
+}
+var upgradeV2toV6 = {
+  name: "v2-to-v6",
+  fromVersion: 2,
+  toVersion: 6,
+  description: "Rebuild orders from event_id PK (v2) to id PK (v6)",
+  replacesChecksums: ["ca6ec5c885f715a3ae65a7101787d66750ed831370dc2ecde0636cfc3cf83e24"],
+  canApply: detectLegacyOrdersPk,
+  apply: applyV2toV6
+};
+
+// src/cli/checksum.ts
+import { createHash } from "crypto";
+import { readFileSync } from "fs";
+function sha256Bytes(contents) {
+  return createHash("sha256").update(contents).digest("hex");
+}
+function sha256File(path) {
+  return sha256Bytes(readFileSync(path));
+}
+
+// src/cli/doctor.ts
+async function runDoctor(options) {
+  const print = options.print ?? (() => {
+  });
+  const lines = [];
+  const installed = currentSchemaVersion();
+  let exitCode = 0;
+  const say = (line) => {
+    lines.push(line);
+    print(line);
+  };
+  say(`installed schema version: ${installed}`);
+  if (!options.executor) {
+    say("no database executor; offline checks only");
+  } else {
+    try {
+      const version = await options.executor.first(
+        "SELECT version, core_version FROM umec_schema_version WHERE id = 1"
+      );
+      if (!version) {
+        say("umec_schema_version: missing (run umec migrate)");
+      } else {
+        say(`database schema version: ${version.version} (core ${version.core_version})`);
+        if (version.version > installed) {
+          exitCode = 1;
+          say(
+            `DB \u306F schema v${version.version}\u3002\u30A4\u30F3\u30B9\u30C8\u30FC\u30EB\u4E2D\u306E @umec/core \u306F v${installed} \u307E\u3067\u3057\u304B\u77E5\u3089\u306A\u3044\u3002\u623B\u3059\u306B\u306F wrangler d1 time-travel restore --bookmark=<\u8A18\u9332\u6E08\u307F> \u306E\u3042\u3068\u540C\u3058 core \u30D0\u30FC\u30B8\u30E7\u30F3\u3092\u5165\u308C\u76F4\u3059\u3053\u3068\u3002down migration \u306F\u7121\u3044\u3002`
+          );
+        }
+      }
+    } catch {
+      say("umec_schema_version: unreadable (run umec migrate)");
+    }
+    const actual = await introspectViaExecutor(options.executor, options.snapshot.version);
+    const drift = classifyDrift(options.snapshot, actual);
+    for (const finding of drift.compatible) say(`warn: ${finding.message}`);
+    for (const finding of drift.incompatible) {
+      exitCode = 1;
+      say(`error: ${finding.message}`);
+    }
+    if (await upgradeV2toV6.canApply(options.executor)) {
+      exitCode = 1;
+      say("error: orders \u306F event_id PK \u306E\u65E7\u30B9\u30AD\u30FC\u30DE\u3067\u3059\u3002umec migrate --repair \u3092\u5B9F\u884C\u3057\u3066\u304F\u3060\u3055\u3044\u3002");
+    }
+    const applied = await options.executor.all(
+      "SELECT name, checksum FROM umec_migrations"
+    ).catch(() => []);
+    const appliedByName = new Map(applied.map((row) => [row.name, row.checksum]));
+    for (const migration of listCoreMigrations()) {
+      const expected = sha256File(migration.path);
+      const got = appliedByName.get(migration.name);
+      if (got && got !== expected) {
+        exitCode = 1;
+        say(`error: checksum mismatch ${migration.name}`);
+      }
+    }
+  }
+  const extensionsPath = join(options.cwd, "src/config/extensions.ts");
+  if (!existsSync(extensionsPath)) {
+    say("warn: src/config/extensions.ts \u304C\u3042\u308A\u307E\u305B\u3093\u3002\u62E1\u5F35\u306F umec extend \u3067 extras_json \u306B\u8DB3\u3057\u3066\u304F\u3060\u3055\u3044\u3002");
+  }
+  return { exitCode, lines };
+}
+async function introspectViaExecutor(executor, version) {
+  const db = {
+    prepare(query) {
+      return {
+        bind(...values) {
+          this._params = values;
+          return this;
+        },
+        _params: [],
+        async first() {
+          return executor.first(query, this._params);
+        },
+        async all() {
+          return { results: await executor.all(query, this._params) };
+        },
+        async run() {
+          const result = await executor.run(query, this._params);
+          return { meta: { changes: result.changes } };
+        }
+      };
+    },
+    async batch() {
+      return [];
+    }
+  };
+  return introspectSnapshot(db, version);
+}
+
+// src/cli/extend.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { dirname, join as join2 } from "path";
+var EXTENSION_TYPES = {
+  boolean: "z.boolean().optional()",
+  string: "z.string().optional()",
+  number: "z.number().optional()"
+};
+var STUB = `import { z } from "zod";
+
+export const orderExtensionSchema = z.object({
+});
+
+export type OrderExtension = z.infer<typeof orderExtensionSchema>;
+`;
+function isExtendType(value) {
+  return value in EXTENSION_TYPES;
+}
+function runExtend(options) {
+  const print = options.print ?? (() => {
+  });
+  const path = join2(options.cwd, "src/config/extensions.ts");
+  mkdirSync(dirname(path), { recursive: true });
+  if (!existsSync2(path)) {
+    writeFileSync(path, STUB);
+    print(`created ${path}`);
+  }
+  const key = options.key;
+  if (!key) {
+    print("\u62E1\u5F35\u306F orders.extras_json \u306B Zod \u3067\u8DB3\u3059\u3002orders \u3092 ALTER \u3057\u306A\u3044\u3053\u3068\u3002");
+    print(`\u7DE8\u96C6\u30D5\u30A1\u30A4\u30EB: ${path}`);
+    return { exitCode: 0, path };
+  }
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+    return { exitCode: 1, path, error: `invalid extras key: ${key}` };
+  }
+  const typeName = options.type ?? "string";
+  if (!isExtendType(typeName)) {
+    return { exitCode: 1, path, error: `unsupported type ${typeName} (boolean|string|number)` };
+  }
+  let source = readFileSync2(path, "utf8");
+  if (new RegExp(`\\b${key}:`).test(source)) {
+    print(`${key} already exists in ${path}`);
+    return { exitCode: 0, path };
+  }
+  if (!source.includes("orderExtensionSchema")) {
+    return { exitCode: 1, path, error: "orderExtensionSchema not found in extensions.ts" };
+  }
+  source = source.replace(
+    /export const orderExtensionSchema = z\.object\(\{\n/,
+    `export const orderExtensionSchema = z.object({
+  ${key}: ${EXTENSION_TYPES[typeName]},
+`
+  );
+  writeFileSync(path, source);
+  print(`added ${key}: ${typeName} to extras_json via ${path}`);
+  print("orders \u30C6\u30FC\u30D6\u30EB\u3092 ALTER \u3057\u306A\u3044\u3053\u3068\u3002\u4E88\u7D04\u5217 extras_json \u3060\u3051\u3092\u4F7F\u3046\u3002");
+  return { exitCode: 0, path };
+}
+
+// src/cli/migrate.ts
+import { readdirSync, readFileSync as readFileSync3 } from "fs";
+import { join as join3 } from "path";
+var CORE_UPGRADES = [upgradeV2toV6];
+async function ensureTracking(executor, dryRun, print) {
+  print("ensure umec_schema_version / umec_migrations");
+  if (dryRun) return;
+  await executor.applySql(TRACKING_TABLES_SQL);
+}
+async function readApplied(executor) {
+  try {
+    return await executor.all("SELECT name, checksum, kind FROM umec_migrations");
+  } catch {
+    return [];
+  }
+}
+async function readVersion(executor) {
+  try {
+    const row = await executor.first(
+      "SELECT version FROM umec_schema_version WHERE id = 1"
+    );
+    return row?.version ?? null;
+  } catch {
+    return null;
+  }
+}
+async function recordMigration(executor, name, checksum, kind, now) {
+  await executor.run(
+    `INSERT INTO umec_migrations (name, checksum, kind, applied_at) VALUES (?, ?, ?, ?)
+     ON CONFLICT(name) DO UPDATE SET checksum = excluded.checksum, kind = excluded.kind, applied_at = excluded.applied_at`,
+    [name, checksum, kind, now]
+  );
+}
+async function writeVersion(executor, version, coreVersion, now, bookmark) {
+  await executor.run(
+    `INSERT INTO umec_schema_version (id, version, core_version, applied_at, time_travel_bookmark)
+     VALUES (1, ?, ?, ?, ?)
+     ON CONFLICT(id) DO UPDATE SET
+       version = excluded.version,
+       core_version = excluded.core_version,
+       applied_at = excluded.applied_at,
+       time_travel_bookmark = excluded.time_travel_bookmark`,
+    [version, coreVersion, now, bookmark]
+  );
+}
+function listLocalMigrations(cwd) {
+  const dir = join3(cwd, "migrations", "local");
+  try {
+    return readdirSync(dir).filter((name) => name.endsWith(".sql")).sort().map((name) => ({
+      name: `local/${name}`,
+      path: join3(dir, name),
+      sql: readFileSync3(join3(dir, name), "utf8")
+    }));
+  } catch {
+    return [];
+  }
+}
+async function adoptD1History(executor, now, print) {
+  const warnings = [];
+  let names = [];
+  try {
+    const rows = await executor.all("SELECT name FROM d1_migrations");
+    names = rows.map((row) => row.name);
+  } catch {
+    throw new Error("d1_migrations \u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002--adopt \u306F wrangler \u7BA1\u7406\u4E0B\u306E\u65E2\u5B58 D1 \u5411\u3051\u3067\u3059\u3002");
+  }
+  const core = listCoreMigrations();
+  const byFile = new Map(core.map((migration) => [migration.name, migration]));
+  const adopted = [];
+  const legacy = await upgradeV2toV6.canApply(executor);
+  for (const rawName of names) {
+    const fileName = rawName.split("/").pop() ?? rawName;
+    const migration = byFile.get(fileName);
+    if (!migration) {
+      warnings.push(`d1_migrations \u306E ${rawName} \u306F core \u306B\u7121\u3044\u306E\u3067\u30B9\u30AD\u30C3\u30D7`);
+      continue;
+    }
+    const checksum = fileName === "0002_orders.sql" && legacy ? upgradeV2toV6.replacesChecksums[0] ?? sha256File(migration.path) : sha256File(migration.path);
+    await recordMigration(executor, migration.name, checksum, "sql", now);
+    adopted.push(migration.name);
+    print(`adopt ${migration.name}`);
+  }
+  return { adopted, warnings };
+}
+async function snapshotFromExecutor(executor, version) {
+  const db = {
+    prepare(query) {
+      return {
+        bind(...values) {
+          this._params = values;
+          return this;
+        },
+        _params: [],
+        async first() {
+          return executor.first(query, this._params);
+        },
+        async all() {
+          const results = await executor.all(query, this._params);
+          return { results };
+        },
+        async run() {
+          const result = await executor.run(query, this._params);
+          return { meta: { changes: result.changes } };
+        }
+      };
+    },
+    async batch() {
+      return [];
+    }
+  };
+  return introspectSnapshot(db, version);
+}
+async function runMigrate(options) {
+  const print = options.print ?? (() => {
+  });
+  const dryRun = options.dryRun === true;
+  const now = options.now ?? Date.now();
+  const applied = [];
+  const warnings = [];
+  const installedVersion = currentSchemaVersion();
+  try {
+    await ensureTracking(options.executor, dryRun, print);
+    const dbVersion = dryRun ? null : await readVersion(options.executor);
+    if (dbVersion != null && dbVersion > installedVersion) {
+      return {
+        exitCode: 1,
+        applied,
+        warnings,
+        error: `DB \u306F schema v${dbVersion}\u3002\u30A4\u30F3\u30B9\u30C8\u30FC\u30EB\u4E2D\u306E @umec/core \u306F v${installedVersion} \u307E\u3067\u3057\u304B\u77E5\u3089\u306A\u3044\u3002\u623B\u3059\u306B\u306F wrangler d1 time-travel restore --bookmark=<\u8A18\u9332\u6E08\u307F> \u306E\u3042\u3068\u540C\u3058 core \u30D0\u30FC\u30B8\u30E7\u30F3\u3092\u5165\u308C\u76F4\u3059\u3053\u3068\u3002down migration \u306F\u7121\u3044\u3002`
+      };
+    }
+    if (options.adopt) {
+      print("adopt d1_migrations \u2192 umec_migrations");
+      if (dryRun) {
+        return { exitCode: 0, applied: ["--adopt"], warnings };
+      }
+      const result = await adoptD1History(options.executor, now, print);
+      applied.push(...result.adopted);
+      warnings.push(...result.warnings);
+      const bookmark2 = await options.executor.captureBookmark();
+      const maxAdopted = result.adopted.reduce((max, name) => Math.max(max, Number(name.slice(0, 4)) || 0), 0);
+      await writeVersion(options.executor, maxAdopted, options.coreVersion, now, bookmark2);
+      return { exitCode: 0, applied, warnings, bookmark: bookmark2 };
+    }
+    if (!dryRun) {
+      const actual = await snapshotFromExecutor(options.executor, options.snapshot.version);
+      const fresh = CORE_TABLES.every((table) => !actual.tables[table]);
+      if (!fresh) {
+        const alreadyForDrift = await readApplied(options.executor);
+        const pendingSql = listCoreMigrations().filter((migration) => !alreadyForDrift.some((row) => row.name === migration.name)).map((migration) => migration.sql).join("\n");
+        const drift = classifyDrift(options.snapshot, actual);
+        for (const finding of drift.compatible) {
+          warnings.push(finding.message);
+          print(`warn: ${finding.message}`);
+        }
+        const blocking = drift.incompatible.filter((finding) => !pendingMigrationFixes(pendingSql, finding));
+        const repairable = options.repair && await upgradeV2toV6.canApply(options.executor);
+        if (blocking.length > 0 && !repairable) {
+          const details = blocking.map((finding) => finding.message).join("; ");
+          const hint = await upgradeV2toV6.canApply(options.executor) ? " umec migrate --repair \u3067 v2-to-v6 \u3092\u63D0\u6848\u3067\u304D\u307E\u3059\u3002" : "";
+          return {
+            exitCode: 1,
+            applied,
+            warnings,
+            error: `\u975E\u4E92\u63DB drift \u306E\u305F\u3081 migrate \u3092\u62D2\u5426: ${details}.${hint}`
+          };
+        }
+      }
+    }
+    const already = dryRun ? [] : await readApplied(options.executor);
+    const alreadyByName = new Map(already.map((row) => [row.name, row]));
+    const coreMigrations = listCoreMigrations();
+    for (const migration of coreMigrations) {
+      const currentHash = sha256File(migration.path);
+      const recorded = alreadyByName.get(migration.name);
+      if (recorded && recorded.checksum !== currentHash) {
+        const knownLegacy = CORE_UPGRADES.some((upgrade) => upgrade.replacesChecksums.includes(recorded.checksum));
+        const canRepair = options.repair && knownLegacy && await upgradeV2toV6.canApply(options.executor);
+        if (!canRepair) {
+          return {
+            exitCode: 1,
+            applied,
+            warnings,
+            error: `\u516C\u958B\u6E08\u307F migration ${migration.name} \u306E checksum \u304C\u98DF\u3044\u9055\u3063\u3066\u3044\u307E\u3059\u3002in-place \u6539\u5909\u306F\u7981\u6B62\u3067\u3059\u3002${knownLegacy ? "umec migrate --repair \u3092\u4F7F\u3063\u3066\u304F\u3060\u3055\u3044\u3002" : ""}`
+          };
+        }
+      }
+    }
+    let bookmark = null;
+    if (!dryRun) {
+      bookmark = await options.executor.captureBookmark();
+      print(bookmark ? `time-travel bookmark ${bookmark}` : "time-travel bookmark unavailable");
+    }
+    if (options.repair) {
+      for (const upgrade of CORE_UPGRADES) {
+        const needed = dryRun ? true : await upgrade.canApply(options.executor);
+        if (!needed) continue;
+        print(`upgrade ${upgrade.name} (${upgrade.fromVersion} \u2192 ${upgrade.toVersion})`);
+        if (dryRun) {
+          applied.push(upgrade.name);
+          continue;
+        }
+        await upgrade.apply(options.executor);
+        await recordMigration(options.executor, upgrade.name, `upgrade:${upgrade.name}`, "upgrade", now);
+        applied.push(upgrade.name);
+        alreadyByName.set(upgrade.name, { name: upgrade.name, checksum: `upgrade:${upgrade.name}`, kind: "upgrade" });
+        for (const supersededName of ["0002_orders.sql", "0005_orders_tracking.sql"]) {
+          const superseded = coreMigrations.find((migration) => migration.name === supersededName);
+          if (!superseded) {
+            throw new Error(`upgradeV2toV6 supersedes unknown migration ${supersededName} \u2014 schema/migrations/ drifted`);
+          }
+          const checksum = sha256File(superseded.path);
+          await recordMigration(options.executor, superseded.name, checksum, "sql", now);
+          alreadyByName.set(superseded.name, { name: superseded.name, checksum, kind: "sql" });
+        }
+      }
+    }
+    for (const migration of coreMigrations) {
+      if (alreadyByName.get(migration.name)?.checksum === sha256File(migration.path)) continue;
+      if (alreadyByName.has(migration.name) && !options.repair) continue;
+      print(`apply core/${migration.name}`);
+      if (dryRun) {
+        applied.push(migration.name);
+        continue;
+      }
+      await options.executor.applySql(migration.sql);
+      await recordMigration(options.executor, migration.name, sha256File(migration.path), "sql", now);
+      applied.push(migration.name);
+    }
+    for (const local of listLocalMigrations(options.cwd)) {
+      const hash = sha256File(local.path);
+      if (alreadyByName.get(local.name)?.checksum === hash) continue;
+      print(`apply ${local.name}`);
+      if (dryRun) {
+        applied.push(local.name);
+        continue;
+      }
+      await options.executor.applySql(local.sql);
+      await recordMigration(options.executor, local.name, hash, "sql", now);
+      applied.push(local.name);
+    }
+    if (!dryRun) {
+      await writeVersion(options.executor, installedVersion, options.coreVersion, now, bookmark);
+    } else {
+      print(`would set umec_schema_version.version = ${installedVersion}`);
+    }
+    return { exitCode: 0, applied, warnings, bookmark };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { exitCode: 1, applied, warnings, error: message };
+  }
+}
+function pendingMigrationFixes(pendingSql, finding) {
+  if (finding.message.includes(`required table "${finding.table}" is missing`)) {
+    return new RegExp(`CREATE TABLE(?: IF NOT EXISTS)?\\s+${finding.table}\\b`, "i").test(pendingSql);
+  }
+  const missingColumn = finding.message.match(/required column "([^."]+)\.([^"]+)" is missing/);
+  if (missingColumn?.[1] && missingColumn[2]) {
+    const [, table, column] = missingColumn;
+    return new RegExp(`ALTER TABLE\\s+${table}\\s+ADD COLUMN\\s+${column}\\b`, "i").test(pendingSql);
+  }
+  return false;
+}
+function coreVersionFromPackage(root = findPackageRoot()) {
+  const pkg = JSON.parse(readFileSync3(join3(root, "package.json"), "utf8"));
+  return pkg.version;
+}
+
+// src/cli/wrangler.ts
+import { spawn } from "child_process";
+import { readFileSync as readFileSync4 } from "fs";
+import { join as join4 } from "path";
+
+// src/cli/executor.ts
+function sqlLiteral(value) {
+  if (value === null || value === void 0) return "NULL";
+  if (typeof value === "boolean") return value ? "1" : "0";
+  if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  if (typeof value === "string") return `'${value.replaceAll("'", "''")}'`;
+  throw new Error(`Unsupported SQL bind: ${typeof value}`);
+}
+function bindSql(sql, params = []) {
+  let index = 0;
+  return sql.replaceAll("?", () => {
+    if (index >= params.length) throw new Error("Not enough SQL bind parameters");
+    return sqlLiteral(params[index++]);
+  });
+}
+
+// src/cli/wrangler.ts
+function defaultRunCommand(command, args, cwd) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      resolve({ code: code ?? 1, stdout, stderr });
+    });
+  });
+}
+function parseJsonc(text) {
+  const stripped = text.replace(/\/\*[\s\S]*?\*\//g, "").replace(/^\s*\/\/.*$/gm, "");
+  return JSON.parse(stripped);
+}
+function readD1DatabaseName(cwd, override) {
+  if (override) return override;
+  const path = join4(cwd, "wrangler.jsonc");
+  try {
+    const parsed = parseJsonc(readFileSync4(path, "utf8"));
+    return parsed.d1_databases?.[0]?.database_name ?? null;
+  } catch {
+    return null;
+  }
+}
+function parseExecuteJson(stdout) {
+  const trimmed = stdout.trim();
+  if (!trimmed) return { results: [], changes: 0 };
+  const start = trimmed.indexOf("[");
+  const objStart = trimmed.indexOf("{");
+  const cut = start >= 0 && (objStart < 0 || start < objStart) ? trimmed.slice(start) : objStart >= 0 ? trimmed.slice(objStart) : trimmed;
+  const parsed = JSON.parse(cut);
+  const rows = Array.isArray(parsed) ? parsed : [parsed];
+  const first = rows[0];
+  return {
+    results: first?.results ?? [],
+    changes: first?.meta?.changes ?? 0
+  };
+}
+function createWranglerExecutor(options) {
+  const runCommand = options.runCommand ?? defaultRunCommand;
+  const location = options.remote ? "--remote" : "--local";
+  const execute = async (sql) => {
+    const result = await runCommand(
+      "wrangler",
+      ["d1", "execute", options.database, location, "--json", "--command", sql],
+      options.cwd
+    );
+    if (result.code !== 0) {
+      throw new Error(result.stderr || result.stdout || `wrangler d1 execute failed (${result.code})`);
+    }
+    return parseExecuteJson(result.stdout);
+  };
+  return {
+    async exec(sql) {
+      await execute(sql);
+    },
+    async applySql(sql) {
+      const { splitSqlStatements: splitSqlStatements2 } = await import("./sql-J4YBS7N7.js");
+      for (const statement of splitSqlStatements2(sql)) {
+        await execute(statement);
+      }
+    },
+    async all(sql, params = []) {
+      const result = await execute(bindSql(sql, params));
+      return result.results;
+    },
+    async first(sql, params = []) {
+      const result = await execute(bindSql(sql, params));
+      return result.results[0] ?? null;
+    },
+    async run(sql, params = []) {
+      const result = await execute(bindSql(sql, params));
+      return { changes: result.changes };
+    },
+    async captureBookmark() {
+      const result = await runCommand(
+        "wrangler",
+        ["d1", "time-travel", "info", options.database, "--json"],
+        options.cwd
+      );
+      if (result.code !== 0) return null;
+      try {
+        const parsed = JSON.parse(result.stdout);
+        return parsed.bookmark ?? null;
+      } catch {
+        return null;
+      }
+    }
+  };
+}
+
+// src/cli/index.ts
+function parseArgs(argv) {
+  const flags = {};
+  let command = null;
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (!arg) continue;
+    if (arg.startsWith("--")) {
+      const eq = arg.indexOf("=");
+      if (eq > 0) {
+        flags[arg.slice(2, eq)] = arg.slice(eq + 1);
+        continue;
+      }
+      const name = arg.slice(2);
+      const next = argv[i + 1];
+      if (next && !next.startsWith("--") && name !== "dry-run" && name !== "adopt" && name !== "repair" && name !== "remote" && name !== "local") {
+        flags[name] = next;
+        i += 1;
+      } else {
+        flags[name] = true;
+      }
+      continue;
+    }
+    if (!command) command = arg;
+  }
+  return { command, flags };
+}
+function usage() {
+  return `Usage:
+  umec migrate [--dry-run] [--local|--remote] [--adopt] [--repair] [--database NAME]
+  umec doctor [--local|--remote] [--database NAME]
+  umec extend [--key NAME] [--type boolean|string|number]`;
+}
+async function runCli(argv, io = {}) {
+  const cwd = io.cwd ?? process.cwd();
+  const stdout = io.stdout ?? ((message) => console.log(message));
+  const stderr = io.stderr ?? ((message) => console.error(message));
+  const { command, flags } = parseArgs(argv);
+  if (!command || command === "help" || flags.help) {
+    stdout(usage());
+    return command ? 0 : 1;
+  }
+  const snapshot = loadSnapshotJson();
+  const remote = flags.remote === true;
+  const database = typeof flags.database === "string" ? flags.database : readD1DatabaseName(cwd);
+  const executor = io.executor ?? (command === "extend" || command === "migrate" && flags["dry-run"] === true ? void 0 : database ? createWranglerExecutor({ cwd, database, remote, runCommand: io.runCommand }) : void 0);
+  if (command === "migrate") {
+    if (flags["dry-run"] === true && !io.executor) {
+      const migrations = (await import("./catalog-5BPLMAW2.js")).listCoreMigrations();
+      stdout("dry-run (no D1 connection)");
+      stdout("ensure umec_schema_version / umec_migrations");
+      for (const migration of migrations) stdout(`apply core/${migration.name}`);
+      stdout(`would set umec_schema_version.version = ${snapshot.version}`);
+      return 0;
+    }
+    if (!executor) {
+      stderr("wrangler.jsonc \u306E d1_databases[0].database_name \u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002--database \u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002");
+      return 1;
+    }
+    const options = {
+      cwd,
+      executor,
+      snapshot,
+      dryRun: flags["dry-run"] === true,
+      adopt: flags.adopt === true,
+      repair: flags.repair === true,
+      coreVersion: coreVersionFromPackage(),
+      print: stdout
+    };
+    const result = await runMigrate(options);
+    for (const warning of result.warnings) stdout(`warn: ${warning}`);
+    if (result.error) stderr(result.error);
+    return result.exitCode;
+  }
+  if (command === "doctor") {
+    const result = await runDoctor({
+      cwd,
+      executor,
+      snapshot,
+      print: stdout
+    });
+    return result.exitCode;
+  }
+  if (command === "extend") {
+    const result = runExtend({
+      cwd,
+      key: typeof flags.key === "string" ? flags.key : void 0,
+      type: typeof flags.type === "string" ? flags.type : void 0,
+      print: stdout
+    });
+    if (result.error) stderr(result.error);
+    return result.exitCode;
+  }
+  stderr(usage());
+  return 1;
+}
+function isDirectRun() {
+  const invoked = process.argv[1];
+  if (!invoked) return false;
+  return /(?:^|[\\/])cli(?:\.js)?$/.test(invoked) || invoked.includes(`${join5("dist", "cli")}`);
+}
+if (isDirectRun()) {
+  const pkg = JSON.parse(readFileSync5(join5(findPackageRoot(), "package.json"), "utf8"));
+  if (process.argv.includes("--version") || process.argv.includes("-V")) {
+    console.log(pkg.version);
+    process.exit(0);
+  }
+  runCli(process.argv.slice(2)).then(
+    (code) => process.exit(code),
+    (error) => {
+      console.error(error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  );
+}
+export {
+  parseArgs,
+  runCli
+};
+//# sourceMappingURL=cli.js.map