@fmaplabs/meta-manifest 0.1.0

package/dist/cli/index.cjs

@@ -0,0 +1,805 @@
+#!/usr/bin/env node
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cli/index.ts
+var cli_exports = {};
+__export(cli_exports, {
+  main: () => main,
+  parseArgs: () => parseArgs
+});
+module.exports = __toCommonJS(cli_exports);
+
+// src/sync/client.ts
+var PULL_DEFINITION_QUERY = `query PullMetaobjectDefinition($type: String!) {
+  metaobjectDefinitionByType(type: $type) {
+    id
+    name
+    type
+    description
+    displayNameKey
+    fieldDefinitions {
+      key
+      name
+      description
+      required
+      type { name }
+      validations { name value }
+    }
+    access { admin storefront }
+    capabilities {
+      publishable { enabled }
+      translatable { enabled }
+      renderable { enabled }
+    }
+  }
+}`;
+var LIST_DEFINITIONS_QUERY = `query ListMetaobjectDefinitions($after: String) {
+  metaobjectDefinitions(first: 50, after: $after) {
+    nodes {
+      id
+      name
+      type
+      fieldDefinitions {
+        key
+        name
+        description
+        required
+        type { name }
+        validations { name value }
+      }
+    }
+    pageInfo { hasNextPage endCursor }
+  }
+}`;
+var CREATE_DEFINITION_MUTATION = `mutation CreateMetaobjectDefinition($definition: MetaobjectDefinitionCreateInput!) {
+  metaobjectDefinitionCreate(definition: $definition) {
+    metaobjectDefinition { id type }
+    userErrors { field message code }
+  }
+}`;
+var UPDATE_DEFINITION_MUTATION = `mutation UpdateMetaobjectDefinition($id: ID!, $definition: MetaobjectDefinitionUpdateInput!) {
+  metaobjectDefinitionUpdate(id: $id, definition: $definition) {
+    metaobjectDefinition { id type }
+    userErrors { field message code }
+  }
+}`;
+var SyncTransportError = class extends Error {
+  constructor(message, errors) {
+    super(message);
+    this.errors = errors;
+    this.name = "SyncTransportError";
+  }
+  errors;
+};
+async function execute(client, query, variables) {
+  const result = await client(query, variables ? { variables } : void 0);
+  if (Array.isArray(result.errors) ? result.errors.length > 0 : result.errors != null) {
+    throw new SyncTransportError("GraphQL request failed", result.errors);
+  }
+  return result.data;
+}
+
+// src/config.ts
+var DEFAULT_API_VERSION = "2026-07";
+function validateConfig(raw) {
+  const c = raw;
+  for (const key of ["shop", "accessToken", "schema"]) {
+    if (!c || typeof c[key] !== "string" || c[key] === "") {
+      throw new Error(`Invalid config: missing or empty "${key}".`);
+    }
+  }
+  return c;
+}
+
+// src/node/client.ts
+function createAdminClient(opts) {
+  const version = opts.apiVersion ?? DEFAULT_API_VERSION;
+  const endpoint = `https://${opts.shop}/admin/api/${version}/graphql.json`;
+  return async (query, options) => {
+    let res;
+    try {
+      res = await fetch(endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "X-Shopify-Access-Token": opts.accessToken },
+        body: JSON.stringify({ query, variables: options?.variables })
+      });
+    } catch (cause) {
+      throw new SyncTransportError(`Request to ${opts.shop} failed`, cause);
+    }
+    if (!res.ok) {
+      throw new SyncTransportError(`Admin API returned HTTP ${res.status}`, await res.text().catch(() => null));
+    }
+    return res.json();
+  };
+}
+
+// src/cli/load-config.ts
+var import_node_path = require("path");
+var import_jiti = require("jiti");
+var import_meta = {};
+var jiti = (0, import_jiti.createJiti)(import_meta.url);
+async function loadConfig(configPath = "meta-manifest.config.ts") {
+  const abs = (0, import_node_path.resolve)(process.cwd(), configPath);
+  const mod = await jiti.import(abs);
+  return validateConfig(mod.default);
+}
+async function loadSchemas(schemaPath) {
+  const abs = (0, import_node_path.resolve)(process.cwd(), schemaPath);
+  const mod = await jiti.import(abs);
+  if (!Array.isArray(mod.schemas)) {
+    throw new Error(`Schema module "${schemaPath}" must export a \`schemas\` array.`);
+  }
+  return mod.schemas;
+}
+
+// src/cli/init.ts
+var import_node_fs = require("fs");
+var import_node_path2 = require("path");
+var CONFIG_TEMPLATE = `import { defineConfig } from "@fmaplabs/meta-manifest";
+
+export default defineConfig({
+  shop: "my-store.myshopify.com",
+  accessToken: process.env.SHOPIFY_ADMIN_TOKEN!,
+  schema: "./src/schema.ts",
+});
+`;
+var SCHEMA_TEMPLATE = `import { defineMetaobject, m } from "@fmaplabs/meta-manifest";
+
+export const Author = defineMetaobject("author", {
+  name: "Author",
+  fields: {
+    name: m.text({ required: true, max: 120 }),
+    bio: m.multilineText(),
+  },
+});
+
+export const schemas = [Author];
+`;
+async function runInit(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const created = [];
+  const write = (rel, contents) => {
+    const abs = (0, import_node_path2.join)(cwd, rel);
+    if ((0, import_node_fs.existsSync)(abs)) return;
+    (0, import_node_fs.mkdirSync)((0, import_node_path2.dirname)(abs), { recursive: true });
+    (0, import_node_fs.writeFileSync)(abs, contents);
+    created.push(rel);
+  };
+  write("meta-manifest.config.ts", CONFIG_TEMPLATE);
+  write("src/schema.ts", SCHEMA_TEMPLATE);
+  if (created.length) {
+    console.log(`Created: ${created.join(", ")}`);
+    console.log("Next: set SHOPIFY_ADMIN_TOKEN in your env, edit meta-manifest.config.ts, then run `mm diff`.");
+  } else {
+    console.log("Nothing to do \u2014 config and schema already exist.");
+  }
+  return { created };
+}
+
+// src/codegen.ts
+var APP_PREFIX = "$app:";
+var SIMPLE = {
+  single_line_text_field: "text",
+  multi_line_text_field: "multilineText",
+  number_integer: "integer",
+  number_decimal: "decimal",
+  boolean: "boolean",
+  date: "date",
+  date_time: "dateTime",
+  url: "url",
+  color: "color",
+  json: "json",
+  money: "money",
+  dimension: "dimension",
+  weight: "weight",
+  volume: "volume",
+  product_reference: "product",
+  variant_reference: "variant",
+  collection_reference: "collection",
+  page_reference: "page",
+  file_reference: "file"
+};
+function handleOf(type) {
+  return type.startsWith(APP_PREFIX) ? type.slice(APP_PREFIX.length) : type;
+}
+function identOf(type) {
+  return handleOf(type).split(/[^a-zA-Z0-9]+/).filter(Boolean).map((p) => p[0].toUpperCase() + p.slice(1)).join("");
+}
+function v(validations, name) {
+  return validations.find((x) => x.name === name)?.value;
+}
+function refTarget(field) {
+  const single = v(field.validations, "metaobject_definition_type");
+  if (single) return single;
+  const many = v(field.validations, "metaobject_definition_types");
+  if (many) {
+    try {
+      const arr = JSON.parse(many);
+      if (Array.isArray(arr) && arr.length) return String(arr[0]);
+    } catch {
+    }
+  }
+  return void 0;
+}
+function optsLiteral(entries) {
+  return entries.length ? `{ ${entries.join(", ")} }` : "";
+}
+function scalarEntries(field, warnings, builder) {
+  const e = [];
+  if (field.required) e.push("required: true");
+  const num = (name, opt) => {
+    const val = v(field.validations, name);
+    if (val !== void 0) e.push(`${opt}: ${Number(val)}`);
+  };
+  const str = (name, opt) => {
+    const val = v(field.validations, name);
+    if (val !== void 0) e.push(`${opt}: ${JSON.stringify(val)}`);
+  };
+  const jsonArr = (name, opt) => {
+    const val = v(field.validations, name);
+    if (val !== void 0) {
+      try {
+        e.push(`${opt}: ${JSON.stringify(JSON.parse(val))}`);
+      } catch {
+        warnings.push(`could not parse "${name}" on field "${field.key}"`);
+      }
+    }
+  };
+  if (builder === "date" || builder === "dateTime") {
+    str("min", "min");
+    str("max", "max");
+  } else {
+    num("min", "min");
+    num("max", "max");
+  }
+  str("regex", "regex");
+  jsonArr("choices", "choices");
+  num("max_precision", "maxPrecision");
+  jsonArr("allowed_domains", "allowedDomains");
+  jsonArr("file_type_options", "accept");
+  return e;
+}
+function scalarCall(builder, field, warnings) {
+  const lit = optsLiteral(scalarEntries(field, warnings, builder));
+  return lit ? `m.${builder}(${lit})` : `m.${builder}()`;
+}
+function fieldCall(field, typeToIdent, warnings) {
+  const type = field.type;
+  if (type === "rating") {
+    const min = v(field.validations, "min");
+    const max = v(field.validations, "max");
+    const e = [`min: ${Number(min ?? 1)}`, `max: ${Number(max ?? 5)}`];
+    if (field.required) e.unshift("required: true");
+    if (min === void 0 || max === void 0) warnings.push(`rating field "${field.key}" missing min/max`);
+    return `m.rating(${optsLiteral(e)})`;
+  }
+  if (type === "metaobject_reference") {
+    const target = refTarget(field);
+    const ident = target ? typeToIdent.get(target) : void 0;
+    if (!ident) {
+      warnings.push(`unresolved reference on field "${field.key}"`);
+      return `m.json() /* TODO: unmapped reference */`;
+    }
+    return field.required ? `m.ref(() => ${ident}, { required: true })` : `m.ref(() => ${ident})`;
+  }
+  if (type.startsWith("list.")) {
+    const inner = type.slice("list.".length);
+    const listEntries = [];
+    if (field.required) listEntries.push("required: true");
+    const min = v(field.validations, "list.min");
+    const max = v(field.validations, "list.max");
+    if (min !== void 0) listEntries.push(`min: ${Number(min)}`);
+    if (max !== void 0) listEntries.push(`max: ${Number(max)}`);
+    const listOpts = optsLiteral(listEntries);
+    let innerCall;
+    if (inner === "metaobject_reference") {
+      const target = refTarget(field);
+      const ident = target ? typeToIdent.get(target) : void 0;
+      if (!ident) {
+        warnings.push(`unresolved list reference on field "${field.key}"`);
+        return `m.json() /* TODO: unmapped list reference */`;
+      }
+      innerCall = `m.ref(() => ${ident})`;
+    } else if (SIMPLE[inner]) {
+      innerCall = scalarCall(SIMPLE[inner], { ...field, required: false }, warnings);
+    } else {
+      warnings.push(`unmapped list element type "${inner}" on field "${field.key}"`);
+      return `m.json() /* TODO: unmapped list element ${inner} */`;
+    }
+    return listOpts ? `m.list(${innerCall}, ${listOpts})` : `m.list(${innerCall})`;
+  }
+  if (SIMPLE[type]) return scalarCall(SIMPLE[type], field, warnings);
+  warnings.push(`unmapped field type "${type}" on field "${field.key}"`);
+  return `m.json() /* TODO: unmapped type ${type} */`;
+}
+function defSource(def, typeToIdent, warnings) {
+  const ident = typeToIdent.get(def.type);
+  const handle = handleOf(def.type);
+  const fields = def.fields.map((f) => `    ${f.key}: ${fieldCall(f, typeToIdent, warnings)},`).join("\n");
+  const name = def.name ? `
+  name: ${JSON.stringify(def.name)},` : "";
+  return `export const ${ident} = defineMetaobject(${JSON.stringify(handle)}, {${name}
+  fields: {
+${fields}
+  },
+});`;
+}
+function referencedTypes(def) {
+  const out = /* @__PURE__ */ new Set();
+  for (const f of def.fields) {
+    if (f.type === "metaobject_reference" || f.type === "list.metaobject_reference") {
+      const t = refTarget(f);
+      if (t) out.add(t);
+    }
+  }
+  return out;
+}
+function orderDefs(defs) {
+  const byType = new Map(defs.map((d) => [d.type, d]));
+  const deps = new Map(defs.map((d) => [d.type, referencedTypes(d)]));
+  const ordered = [];
+  const placed = /* @__PURE__ */ new Set();
+  let progress = true;
+  while (ordered.length < defs.length && progress) {
+    progress = false;
+    for (const d of defs) {
+      if (placed.has(d.type)) continue;
+      const unmet = [...deps.get(d.type) ?? []].filter((t) => byType.has(t) && !placed.has(t) && t !== d.type);
+      if (unmet.length === 0) {
+        ordered.push(d);
+        placed.add(d.type);
+        progress = true;
+      }
+    }
+  }
+  for (const d of defs) if (!placed.has(d.type)) ordered.push(d);
+  return ordered;
+}
+function generateSchemaSource(defs) {
+  const ordered = orderDefs(defs);
+  const typeToIdent = new Map(ordered.map((d) => [d.type, identOf(d.type)]));
+  const warnings = [];
+  const blocks = ordered.map((d) => defSource(d, typeToIdent, warnings));
+  const idents = ordered.map((d) => typeToIdent.get(d.type));
+  const header = `import { defineMetaobject, m } from "@fmaplabs/meta-manifest";`;
+  const body = blocks.join("\n\n");
+  const footer = `export const schemas = [${idents.join(", ")}];`;
+  for (const w of warnings) console.warn(`[meta-manifest] codegen: ${w}`);
+  return `${header}
+
+${body}
+
+${footer}
+`;
+}
+
+// src/sync/diff.ts
+function sameValidations(a, b) {
+  const norm = (v2) => JSON.stringify([...v2].sort((x, y) => x.name.localeCompare(y.name)));
+  return norm(a) === norm(b);
+}
+function diff(local, remote) {
+  const ops = [];
+  const remoteByType = new Map(remote.map((d) => [d.type, d]));
+  for (const localDef of local) {
+    const remoteDef = remoteByType.get(localDef.type);
+    if (!remoteDef) {
+      ops.push({ kind: "createDefinition", type: localDef.type, definition: localDef });
+      continue;
+    }
+    const remoteFields = new Map(remoteDef.fields.map((f) => [f.key, f]));
+    const localKeys = new Set(localDef.fields.map((f) => f.key));
+    for (const lf of localDef.fields) {
+      const rf = remoteFields.get(lf.key);
+      if (!rf) {
+        ops.push({ kind: "addField", type: localDef.type, field: lf });
+        continue;
+      }
+      if (rf.type !== lf.type) {
+        ops.push({ kind: "changeFieldType", type: localDef.type, key: lf.key, from: rf.type, to: lf.type, destructive: true });
+        continue;
+      }
+      const changes = {};
+      if (rf.required !== lf.required) changes.required = lf.required;
+      if (!sameValidations(rf.validations, lf.validations)) changes.validations = lf.validations;
+      if (Object.keys(changes).length) {
+        ops.push({ kind: "updateField", type: localDef.type, key: lf.key, changes });
+      }
+    }
+    for (const rf of remoteDef.fields) {
+      if (!localKeys.has(rf.key)) {
+        ops.push({ kind: "removeField", type: localDef.type, key: rf.key, destructive: true });
+      }
+    }
+  }
+  return ops;
+}
+
+// src/sync/normalize.ts
+function normalizeLocal(schema) {
+  const def = schema.toDefinitionInput();
+  return {
+    type: def.type,
+    name: def.name,
+    fields: def.fieldDefinitions.map((f) => ({
+      key: f.key,
+      type: f.type,
+      required: f.required,
+      validations: f.validations
+    }))
+  };
+}
+function normalizeRemote(def) {
+  return {
+    type: def.type,
+    name: def.name,
+    fields: def.fieldDefinitions.map((f) => ({
+      key: f.key,
+      type: typeof f.type === "string" ? f.type : f.type.name,
+      required: f.required,
+      validations: f.validations ?? []
+    }))
+  };
+}
+
+// src/sync/pull.ts
+async function pull(client, types) {
+  const out = [];
+  for (const type of types) {
+    const data = await execute(client, PULL_DEFINITION_QUERY, { type });
+    const node = data.metaobjectDefinitionByType;
+    if (!node) continue;
+    out.push({
+      id: node.id,
+      type,
+      definition: { type, name: node.name, fieldDefinitions: node.fieldDefinitions }
+    });
+  }
+  return out;
+}
+function toCanonicalType(resolved) {
+  const m2 = /^app--\d+--(.+)$/.exec(resolved);
+  return m2 ? `$app:${m2[1]}` : null;
+}
+async function pullAll(client, opts = {}) {
+  const appOwnedOnly = opts.appOwnedOnly ?? true;
+  const out = [];
+  let after = null;
+  do {
+    const data = await execute(client, LIST_DEFINITIONS_QUERY, { after });
+    for (const node of data.metaobjectDefinitions.nodes) {
+      const canonical = toCanonicalType(node.type);
+      if (appOwnedOnly && !canonical) continue;
+      const type = canonical ?? node.type;
+      out.push({ id: node.id, type, definition: { type, name: node.name, fieldDefinitions: node.fieldDefinitions } });
+    }
+    after = data.metaobjectDefinitions.pageInfo.hasNextPage ? data.metaobjectDefinitions.pageInfo.endCursor : null;
+  } while (after !== null);
+  return out;
+}
+
+// src/sync/push.ts
+function fieldInputFor(defByType, type, key) {
+  return defByType.get(type)?.fieldDefinitions.find((f) => f.key === key);
+}
+function referenceEdges(def) {
+  const out = [];
+  for (const field of def.fieldDefinitions) {
+    for (const v2 of field.validations) {
+      if (v2.name === "metaobject_definition_type") {
+        out.push(v2.value);
+      } else if (v2.name === "metaobject_definition_types") {
+        try {
+          const parsed = JSON.parse(v2.value);
+          if (Array.isArray(parsed)) {
+            for (const t of parsed) if (typeof t === "string") out.push(t);
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  return out;
+}
+function topoSortCreates(types, deps) {
+  const remaining = /* @__PURE__ */ new Map();
+  const dependents = /* @__PURE__ */ new Map();
+  for (const t of types) {
+    const d = deps.get(t) ?? /* @__PURE__ */ new Set();
+    remaining.set(t, d.size);
+    for (const dep of d) {
+      const list2 = dependents.get(dep) ?? [];
+      list2.push(t);
+      dependents.set(dep, list2);
+    }
+  }
+  const queue = [];
+  for (const t of types) if ((remaining.get(t) ?? 0) === 0) queue.push(t);
+  const ordered = [];
+  while (queue.length) {
+    const t = queue.shift();
+    ordered.push(t);
+    for (const dependent of dependents.get(t) ?? []) {
+      const r = (remaining.get(dependent) ?? 0) - 1;
+      remaining.set(dependent, r);
+      if (r === 0) queue.push(dependent);
+    }
+  }
+  const orderedSet = new Set(ordered);
+  return { ordered, unordered: [...types].filter((t) => !orderedSet.has(t)) };
+}
+async function push(client, plan, sources, options) {
+  const allowDestructive = options?.allowDestructive ?? false;
+  const defByType = new Map(sources.definitions.map((d) => [d.type, d]));
+  const idByType = new Map(sources.remote.map((r) => [r.type, r.id]));
+  const indexed = plan.map((op, index) => ({ op, index }));
+  const createOps = indexed.filter((x) => x.op.kind === "createDefinition");
+  const otherOps = indexed.filter((x) => x.op.kind !== "createDefinition");
+  const createTypes = new Set(createOps.map((x) => x.op.type));
+  const deps = /* @__PURE__ */ new Map();
+  for (const { op } of createOps) {
+    const def = defByType.get(op.type);
+    const targets = def ? referenceEdges(def) : [];
+    deps.set(op.type, new Set(targets.filter((t) => createTypes.has(t) && t !== op.type)));
+  }
+  const { ordered, unordered } = topoSortCreates(createTypes, deps);
+  const orderedSet = new Set(ordered);
+  const cyclicTypes = new Set(unordered);
+  const createByType = new Map(createOps.map((x) => [x.op.type, x]));
+  const execOrder = [
+    ...ordered.map((t) => createByType.get(t)),
+    ...createOps.filter((x) => !orderedSet.has(x.op.type)),
+    ...otherOps
+  ];
+  const failedTypes = /* @__PURE__ */ new Set();
+  async function applyOp(op) {
+    if (op.kind === "createDefinition") {
+      if (cyclicTypes.has(op.type)) {
+        failedTypes.add(op.type);
+        return { op, status: "blocked", reason: "reference cycle \u2014 two-pass create deferred" };
+      }
+      for (const dep of deps.get(op.type) ?? []) {
+        if (failedTypes.has(dep)) {
+          failedTypes.add(op.type);
+          return { op, status: "blocked", reason: `blocked: dependency "${dep}" was not created` };
+        }
+      }
+      const def = defByType.get(op.type);
+      if (!def) {
+        failedTypes.add(op.type);
+        return { op, status: "blocked", reason: `no definition input for "${op.type}"` };
+      }
+      const data2 = await execute(client, CREATE_DEFINITION_MUTATION, { definition: def });
+      const payload2 = data2.metaobjectDefinitionCreate;
+      if (payload2.userErrors.length) {
+        failedTypes.add(op.type);
+        return { op, status: "failed", userErrors: payload2.userErrors };
+      }
+      const id2 = payload2.metaobjectDefinition?.id;
+      if (id2) idByType.set(op.type, id2);
+      return { op, status: "applied", id: id2 };
+    }
+    const destructive = op.kind === "removeField" || op.kind === "changeFieldType";
+    if (destructive && !allowDestructive) return { op, status: "skipped", reason: "destructive" };
+    if (failedTypes.has(op.type)) return { op, status: "blocked", reason: `blocked: definition "${op.type}" was not created` };
+    const id = idByType.get(op.type);
+    if (id == null) return { op, status: "blocked", reason: `no definition id for "${op.type}"` };
+    const fieldDefinitions = fieldOpsFor(op);
+    if (!fieldDefinitions) return { op, status: "blocked", reason: `no field input for "${op.type}"` };
+    const data = await execute(client, UPDATE_DEFINITION_MUTATION, { id, definition: { fieldDefinitions } });
+    const payload = data.metaobjectDefinitionUpdate;
+    if (payload.userErrors.length) return { op, status: "failed", userErrors: payload.userErrors };
+    return { op, status: "applied", id: payload.metaobjectDefinition?.id ?? id };
+  }
+  function fieldOpsFor(op) {
+    switch (op.kind) {
+      case "addField": {
+        const field = fieldInputFor(defByType, op.type, op.field.key);
+        return field ? [{ create: field }] : void 0;
+      }
+      case "updateField": {
+        const field = fieldInputFor(defByType, op.type, op.key);
+        if (!field) return void 0;
+        const update = {
+          key: field.key,
+          name: field.name,
+          required: field.required,
+          validations: field.validations
+        };
+        if (field.description != null) update.description = field.description;
+        return [{ update }];
+      }
+      case "removeField":
+        return [{ delete: { key: op.key } }];
+      case "changeFieldType": {
+        const field = fieldInputFor(defByType, op.type, op.key);
+        return field ? [{ delete: { key: op.key } }, { create: field }] : void 0;
+      }
+      default:
+        return void 0;
+    }
+  }
+  const results = new Array(plan.length);
+  for (const { op, index } of execOrder) results[index] = await applyOp(op);
+  const counts = { applied: 0, skipped: 0, blocked: 0, failed: 0 };
+  for (const r of results) counts[r.status]++;
+  return { results, counts, ok: counts.failed === 0 && counts.blocked === 0 };
+}
+
+// src/cli/plan.ts
+async function planFor(client, schemas) {
+  const types = schemas.map((s) => s.type);
+  const localDefs = schemas.map(normalizeLocal);
+  const remote = await pull(client, types);
+  const plan = diff(localDefs, remote.map((r) => normalizeRemote(r.definition)));
+  return { plan, remote };
+}
+
+// src/cli/format.ts
+function opTarget(op) {
+  if (op.kind === "addField") return `${op.type}.${op.field.key}`;
+  if ("key" in op) return `${op.type}.${op.key}`;
+  return op.type;
+}
+function isDestructive(op) {
+  return "destructive" in op && op.destructive === true;
+}
+function describeOp(op) {
+  return `${op.kind}: ${opTarget(op)}${isDestructive(op) ? " \xB7 destructive" : ""}`;
+}
+function describeResult(r) {
+  const head = `${r.op.kind}: ${opTarget(r.op)}`;
+  switch (r.status) {
+    case "applied":
+      return `\u2713 applied \u2014 ${head}`;
+    case "skipped":
+      return `\u2013 skipped (${r.reason}) \u2014 ${head}`;
+    case "blocked":
+      return `\u26A0 blocked (${r.reason}) \u2014 ${head}`;
+    case "failed":
+      return `\u2717 failed (${r.userErrors.map((e) => e.message).join("; ")}) \u2014 ${head}`;
+  }
+}
+
+// src/cli/diff.ts
+async function runDiff(args) {
+  const { plan } = await planFor(args.client, args.schemas);
+  if (plan.length === 0) {
+    console.log("Everything is in sync \u2014 nothing to apply.");
+  } else {
+    console.log(`${plan.length} change${plan.length === 1 ? "" : "s"} would be applied:`);
+    for (const op of plan) console.log(`  ${describeOp(op)}`);
+  }
+  return plan;
+}
+
+// src/cli/push.ts
+async function runPush(args) {
+  const { plan, remote } = await planFor(args.client, args.schemas);
+  const definitions = args.schemas.map((s) => s.toDefinitionInput());
+  const result = await push(args.client, plan, { definitions, remote }, { allowDestructive: args.allowDestructive });
+  for (const r of result.results) console.log(`  ${describeResult(r)}`);
+  console.log(
+    `applied ${result.counts.applied} \xB7 skipped ${result.counts.skipped} \xB7 blocked ${result.counts.blocked} \xB7 failed ${result.counts.failed}`
+  );
+  if (!args.allowDestructive && plan.some(isDestructive)) {
+    console.log("Some destructive changes were skipped. Re-run with --allow-destructive to apply them.");
+  }
+  return result;
+}
+
+// src/cli/pull.ts
+var import_node_fs2 = require("fs");
+var import_node_path3 = require("path");
+async function maybeFormat(source) {
+  try {
+    const spec = "prettier";
+    const prettier = await import(spec);
+    return await prettier.format(source, { parser: "typescript" });
+  } catch {
+    return source;
+  }
+}
+async function runPull(args) {
+  const remote = await pullAll(args.client);
+  const defs = remote.map((r) => normalizeRemote(r.definition));
+  const source = await maybeFormat(generateSchemaSource(defs));
+  const abs = (0, import_node_path3.resolve)(process.cwd(), args.schemaPath);
+  if ((0, import_node_fs2.existsSync)(abs) && !args.force) {
+    console.warn(`Overwriting existing ${args.schemaPath}.`);
+  }
+  (0, import_node_fs2.mkdirSync)((0, import_node_path3.dirname)(abs), { recursive: true });
+  (0, import_node_fs2.writeFileSync)(abs, source);
+  console.log(`Wrote ${defs.length} definition${defs.length === 1 ? "" : "s"} to ${args.schemaPath}.`);
+  return { written: abs, count: defs.length };
+}
+
+// src/cli/index.ts
+function parseArgs(argv) {
+  const args = { allowDestructive: false, force: false, help: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--help" || a === "-h") args.help = true;
+    else if (a === "--allow-destructive") args.allowDestructive = true;
+    else if (a === "--force") args.force = true;
+    else if (a === "--config") args.config = argv[++i];
+    else if (!a.startsWith("-") && !args.command) args.command = a;
+  }
+  return args;
+}
+var HELP = `meta-manifest \u2014 sync Shopify metaobject definitions
+
+Usage: mm <command> [options]
+
+Commands:
+  init                 Scaffold meta-manifest.config.ts + src/schema.ts
+  pull                 Enumerate remote definitions and write schema source
+  diff                 Show the changes a push would apply
+  push                 Apply local schema to the store
+
+Options:
+  --config <path>      Config file (default: meta-manifest.config.ts)
+  --allow-destructive  Apply destructive changes on push
+  --force              Overwrite schema on pull without warning
+  -h, --help           Show this help`;
+async function main(argv) {
+  const args = parseArgs(argv);
+  if (args.help || !args.command) {
+    console.log(HELP);
+    return args.command ? 0 : args.help ? 0 : 1;
+  }
+  try {
+    if (args.command === "init") {
+      await runInit();
+      return 0;
+    }
+    const config = await loadConfig(args.config);
+    const client = createAdminClient(config);
+    if (args.command === "pull") {
+      await runPull({ client, schemaPath: config.schema, force: args.force });
+      return 0;
+    }
+    const schemas = await loadSchemas(config.schema);
+    if (args.command === "diff") {
+      await runDiff({ client, schemas });
+      return 0;
+    }
+    if (args.command === "push") {
+      const result = await runPush({ client, schemas, allowDestructive: args.allowDestructive });
+      return result.ok ? 0 : 2;
+    }
+    console.error(`Unknown command: ${args.command}`);
+    console.log(HELP);
+    return 1;
+  } catch (err) {
+    if (err instanceof SyncTransportError) console.error(`Sync failed: Shopify rejected a request.`);
+    else console.error(err instanceof Error ? err.message : String(err));
+    return 1;
+  }
+}
+if (process.env.VITEST === void 0) {
+  main(process.argv.slice(2)).then((code) => process.exit(code));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  main,
+  parseArgs
+});
+//# sourceMappingURL=index.cjs.map