@zalify/cli 0.9.1 → 0.11.0

package/dist/cli.js

@@ -11293,7 +11293,7 @@ function updateNotifier(options) {
 
 // src/cli.ts
 import { createRequire as createRequire2 } from "node:module";
-import { dirname as dirname2, join as join7 } from "node:path";
+import { dirname as dirname2, join as join8 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // src/auth.ts
@@ -12064,9 +12064,9 @@ async function imagesGenerate(storeDir) {
 import { readFileSync as readFileSync6, existsSync as existsSync6 } from "node:fs";
 import { basename as basename3, join as join6, resolve as resolve5 } from "node:path";
 
-// src/storefront.ts
-import { spawnSync as spawnSync3 } from "node:child_process";
-import { existsSync as existsSync5, readFileSync as readFileSync5 } from "node:fs";
+// src/site.ts
+import { spawn as spawn3, spawnSync as spawnSync3 } from "node:child_process";
+import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync6 } from "node:fs";
 import { basename as basename2, join as join5, resolve as resolve4 } from "node:path";
 
 // src/theme.ts
@@ -12493,11 +12493,11 @@ function mergePackageJson(projectDir, oldDir, newDir, dryRun) {
   return depsChanged;
 }
 
-// src/storefront.ts
+// src/site.ts
 function apiError2(status, json, appUrl) {
   if (status === 402) {
     return new Error(`${json.error ?? "Upgrade required"}
-` + `  Storefront hosting is a paid feature — upgrade the workspace in ${appUrl}`);
+` + `  Site hosting is a paid feature — upgrade the workspace in ${appUrl}`);
   }
   if (json.code === "NO_CONNECTION") {
     return new Error(`${json.error}
@@ -12508,40 +12508,44 @@ function apiError2(status, json, appUrl) {
   Pick a different directory/slug name.`);
   }
   if (status === 404) {
-    return new Error("The storefronts API is not deployed yet (404). Update app.zalify.com first.");
+    return new Error("The sites API is not deployed yet (404). Update app.zalify.com first.");
   }
   if (status === 503) {
-    return new Error(json.error ?? "Storefront provisioning is not configured on the server.");
+    return new Error(json.error ?? "Site provisioning is not configured on the server.");
   }
-  return new Error(`storefronts API ${status}: ${JSON.stringify(json)}`);
+  return new Error(`sites API ${status}: ${JSON.stringify(json)}`);
 }
-async function post(auth, path9, body) {
-  const res = await fetch(`${auth.appUrl}${path9}`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json", Authorization: `Bearer ${auth.key}` },
-    body: JSON.stringify({ workspaceId: auth.workspaceId, ...body })
-  });
+async function request(auth, method, path9, body) {
+  const attempt = async (p) => {
+    const url = method === "GET" ? `${auth.appUrl}${p}${p.includes("?") ? "&" : "?"}workspaceId=${auth.workspaceId}` : `${auth.appUrl}${p}`;
+    return fetch(url, {
+      method,
+      headers: {
+        Authorization: `Bearer ${auth.key}`,
+        ...method === "POST" ? { "Content-Type": "application/json" } : {}
+      },
+      ...method === "POST" ? { body: JSON.stringify({ workspaceId: auth.workspaceId, ...body }) } : {}
+    });
+  };
+  let res = await attempt(path9);
+  if (res.status === 404 && path9.startsWith("/api/sites")) {
+    res = await attempt(path9.replace("/api/sites", "/api/storefronts"));
+  }
   const json = await res.json().catch(() => ({}));
   if (!res.ok)
     throw apiError2(res.status, json, auth.appUrl);
   return json;
 }
-async function get(auth, path9) {
-  const sep = path9.includes("?") ? "&" : "?";
-  const res = await fetch(`${auth.appUrl}${path9}${sep}workspaceId=${auth.workspaceId}`, {
-    headers: { Authorization: `Bearer ${auth.key}` }
-  });
-  const json = await res.json().catch(() => ({}));
-  if (!res.ok)
-    throw apiError2(res.status, json, auth.appUrl);
-  return json;
+async function listSites(auth) {
+  const json = await request(auth, "GET", "/api/sites");
+  return json.sites ?? json.storefronts ?? [];
 }
 var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
 async function pollUntilReady(auth, id) {
   let lastMessage = "";
   const deadline = Date.now() + 10 * 60000;
   while (Date.now() < deadline) {
-    const view = await get(auth, `/api/storefronts/${id}`);
+    const view = await request(auth, "GET", `/api/sites/${id}`);
     const message = view.statusMessage ?? view.status;
     if (message !== lastMessage) {
       console.log(`  … ${message}`);
@@ -12556,16 +12560,19 @@ async function pollUntilReady(auth, id) {
   }
   throw new Error("Provisioning timed out after 10 minutes — check the Temporal UI.");
 }
-async function storefrontCreate(dir2, opts) {
+async function siteCreate(dir2, opts) {
   const auth = requireActive();
-  const slug = basename2(resolve4(dir2)).toLowerCase().replaceAll(/[^a-z0-9-]+/g, "-").replaceAll(/^-+|-+$/g, "") || "storefront";
-  console.log(`Provisioning storefront "${slug}" (workspace "${auth.workspaceName}")`);
-  const { storefrontId } = await post(auth, "/api/storefronts", {
+  const slug = basename2(resolve4(dir2)).toLowerCase().replaceAll(/[^a-z0-9-]+/g, "-").replaceAll(/^-+|-+$/g, "") || "site";
+  console.log(`Provisioning site "${slug}" (workspace "${auth.workspaceName}")`);
+  const created = await request(auth, "POST", "/api/sites", {
     slug,
     theme: opts.theme ?? "nextjs",
     ...opts.to ? { themeVersion: opts.to } : {}
   });
-  const view = await pollUntilReady(auth, storefrontId);
+  const siteId = created.siteId ?? created.storefrontId;
+  if (!siteId)
+    throw new Error("provisioning API returned no site id");
+  const view = await pollUntilReady(auth, siteId);
   console.log(`  ✓ provisioned: ${view.githubRepo} → https://${view.domain}`);
   await themeCreate(dir2, {
     template: view.theme,
@@ -12576,9 +12583,13 @@ async function storefrontCreate(dir2, opts) {
     install: opts.install,
     git: opts.git
   });
+  writeFileSync6(join5(resolve4(dir2), ".zalify", "site.json"), JSON.stringify({ id: siteId, slug: view.slug, domain: view.domain, repo: view.githubRepo }, null, 2) + `
+`);
   if (opts.git !== false && view.githubRepo) {
-    const { token, repo } = await post(auth, `/api/storefronts/${storefrontId}/push-token`, {});
+    const { token, repo } = await request(auth, "POST", `/api/sites/${siteId}/push-token`, {});
     const run = (args) => spawnSync3("git", args, { cwd: resolve4(dir2), stdio: "ignore" });
+    run(["add", ".zalify/site.json"]);
+    run(["commit", "-m", "Link site record", "--no-verify"]);
     run(["remote", "add", "origin", `https://github.com/${repo}.git`]);
     const push = spawnSync3("git", ["push", `https://x-access-token:${token}@github.com/${repo}.git`, "main"], { cwd: resolve4(dir2), stdio: "inherit" });
     if (push.status !== 0) {
@@ -12587,7 +12598,7 @@ async function storefrontCreate(dir2, opts) {
     run(["update-ref", "refs/remotes/origin/main", "HEAD"]);
     run(["config", "branch.main.remote", "origin"]);
     run(["config", "branch.main.merge", "refs/heads/main"]);
-    console.log(`  ✓ pushed to github.com/${repo} — Vercel deploys on push`);
+    console.log(`  ✓ pushed to github.com/${repo} — deploys on push`);
   }
   if (view.domain) {
     console.log(`  Waiting for https://${view.domain} …`);
@@ -12607,49 +12618,89 @@ Live: https://${view.domain}`);
   console.log(`
 Next steps:
 ` + `  - author your theme in ${dir2}/theme/ (see theme/README.md), commit + push
-` + `  - zalify shopify import stores/<slug> --prune   # catalog (auto-flushes the site cache)
-` + `  - zalify theme status ${dir2}                    # drift check anytime`);
+` + `  - zalify brand push <brand-dir> --prune    # catalog (auto-refreshes this site)
+` + `  - zalify site open ${slug}                 # see it live
+` + `  - zalify theme status ${dir2}               # drift check anytime`);
+}
+async function resolveSite(auth, slugOrDir) {
+  const fromDir = (dir2) => {
+    const link = join5(dir2, ".zalify", "site.json");
+    if (existsSync5(link)) {
+      const parsed = JSON.parse(readFileSync5(link, "utf8"));
+      if (parsed.slug)
+        return parsed.slug;
+    }
+    const storeJson = join5(dir2, "store.json");
+    if (existsSync5(storeJson)) {
+      const parsed = JSON.parse(readFileSync5(storeJson, "utf8"));
+      if (parsed.slug)
+        return parsed.slug;
+    }
+    return null;
+  };
+  let slug = null;
+  if (slugOrDir && existsSync5(resolve4(slugOrDir)))
+    slug = fromDir(resolve4(slugOrDir));
+  if (!slug && slugOrDir)
+    slug = slugOrDir;
+  if (!slug)
+    slug = fromDir(process.cwd());
+  const sites = await listSites(auth);
+  if (slug) {
+    const match = sites.find((s) => s.slug === slug);
+    if (match)
+      return match;
+    throw new Error(`No site "${slug}" in workspace "${auth.workspaceName}".
+` + `  Sites here: ${sites.map((s) => s.slug).join(", ") || "(none)"}`);
+  }
+  if (sites.length === 1)
+    return sites[0];
+  throw new Error(sites.length === 0 ? `No sites in workspace "${auth.workspaceName}" — create one with \`zalify site create <dir>\`.` : `Multiple sites in this workspace — name one: ${sites.map((s) => s.slug).join(", ")}`);
 }
-async function storefrontList() {
+async function siteList() {
   const auth = requireActive();
-  const { storefronts } = await get(auth, "/api/storefronts");
-  if (!storefronts.length) {
-    console.log(`No storefronts in workspace "${auth.workspaceName}".`);
+  const sites = await listSites(auth);
+  if (!sites.length) {
+    console.log(`No sites in workspace "${auth.workspaceName}".`);
     return;
   }
-  for (const s of storefronts) {
-    const site = s.domain ? `https://${s.domain}` : "-";
-    console.log(`${s.status === "READY" ? "✓" : s.status === "FAILED" ? "✗" : "…"} ${s.slug}  ${site}  (${s.status.toLowerCase()}${s.githubRepo ? `, ${s.githubRepo}` : ""})`);
+  for (const s of sites) {
+    const url = s.domain ? `https://${s.domain}` : "-";
+    console.log(`${s.status === "READY" ? "✓" : s.status === "FAILED" ? "✗" : "…"} ${s.slug}  ${url}  (${s.status.toLowerCase()}${s.githubRepo ? `, ${s.githubRepo}` : ""})`);
   }
 }
-function resolveSlug(slugOrDir) {
-  const storeJson = join5(resolve4(slugOrDir), "store.json");
-  if (existsSync5(storeJson)) {
-    const parsed = JSON.parse(readFileSync5(storeJson, "utf8"));
-    if (parsed.slug)
-      return parsed.slug;
-  }
-  return basename2(slugOrDir);
+async function siteRefresh(slugOrDir) {
+  const auth = requireActive();
+  const site = await resolveSite(auth, slugOrDir);
+  await request(auth, "POST", `/api/sites/${site.id}/revalidate`, {});
+  console.log(`✓ refreshed https://${site.domain}`);
 }
-async function storefrontRevalidate(slugOrDir) {
+async function siteOpen(slugOrDir) {
   const auth = requireActive();
-  const slug = resolveSlug(slugOrDir);
-  const { storefronts } = await get(auth, "/api/storefronts");
-  const match = storefronts.find((s) => s.slug === slug);
-  if (!match)
-    throw new Error(`No storefront "${slug}" in workspace "${auth.workspaceName}".`);
-  await post(auth, `/api/storefronts/${match.id}/revalidate`, {});
-  console.log(`✓ flushed cache on https://${match.domain}`);
-}
-async function maybeRevalidateStorefront(auth, storeDir) {
+  const site = await resolveSite(auth, slugOrDir);
+  if (!site.domain)
+    throw new Error(`Site "${site.slug}" has no domain yet.`);
+  const url = `https://${site.domain}`;
+  const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  spawn3(opener, [url], { detached: true, stdio: "ignore" }).unref();
+  console.log(url);
+}
+async function maybeRefreshSites(auth, brandDir, siteSlugOverride) {
   try {
-    const slug = resolveSlug(storeDir);
-    const { storefronts } = await get(auth, "/api/storefronts");
-    const match = storefronts.find((s) => s.slug === slug && s.status === "READY");
-    if (!match)
+    let slug = siteSlugOverride ?? null;
+    if (!slug) {
+      const storeJson = join5(resolve4(brandDir), "store.json");
+      if (existsSync5(storeJson)) {
+        slug = JSON.parse(readFileSync5(storeJson, "utf8")).slug ?? null;
+      }
+    }
+    if (!slug)
       return;
-    await post(auth, `/api/storefronts/${match.id}/revalidate`, {});
-    console.log(`✓ site cache flushed (https://${match.domain})`);
+    const sites = (await listSites(auth)).filter((s) => s.slug === slug && s.status === "READY");
+    for (const site of sites) {
+      await request(auth, "POST", `/api/sites/${site.id}/revalidate`, {});
+      console.log(`✓ site refreshed (https://${site.domain})`);
+    }
   } catch {}
 }
 
@@ -12829,9 +12880,9 @@ async function shopifyImport(storeDir, options = {}) {
     console.warn(`  ! could not publish to Online Store (write_publications scope missing?): ${e instanceof Error ? e.message : String(e)}`);
   }
   console.log("Done.");
-  await maybeRevalidateStorefront(auth, dir2);
+  await maybeRefreshSites(auth, dir2, options.site);
 }
-async function shopifyUploadImages(storeDir) {
+async function shopifyUploadImages(storeDir, options = {}) {
   const auth = requireActive();
   const dir2 = resolve5(storeDir);
   const manifest = readJson(join6(dir2, "images", "manifest.json"), "images/manifest.json");
@@ -12907,13 +12958,336 @@ async function shopifyUploadImages(storeDir) {
       console.log(`  ✓ ${entry.file}`);
   }
   console.log("Done.");
-  await maybeRevalidateStorefront(auth, dir2);
+  await maybeRefreshSites(auth, dir2, options.site);
+}
+
+// src/brand.ts
+import { existsSync as existsSync7, mkdirSync as mkdirSync3, readdirSync as readdirSync3, readFileSync as readFileSync7, writeFileSync as writeFileSync7 } from "node:fs";
+import { basename as basename4, join as join7, resolve as resolve6 } from "node:path";
+var AUTHORING_MD = `# Brand authoring guide
+
+The rules for filling in this folder. An author — human or AI agent —
+should be able to produce a complete, import-ready brand from this file
+alone. Validate anytime with \`zalify brand validate\` (defaults to cwd).
+
+## Files
+
+| File | Role |
+| ---- | ---- |
+| store.json | the Shopify store this brand connects to (name, slug, vertical, currency; storeDomain filled in once the store exists) |
+| brand.md | brand voice guide — tone, audience, naming, price band. Written FIRST; everything else follows it |
+| catalog.json | canonical catalog (products + collections) — the single source the pipeline imports |
+| images/manifest.json | one entry per shot + shared style/modelStyle art-direction prefixes |
+| images/*.png | generated masters (NOT committed — they live in the Zalify asset library; images/assets.json is the committed index) |
+
+## catalog.json rules
+
+- 10–14 products is the sweet spot for a demo brand; every product needs
+  \`handle\` (unique, kebab-case, no SKU-speak), \`title\`, \`descriptionHtml\`
+  (brand voice; simple HTML: p/ul/li/em only), \`type\`, \`tags\`, \`variants\`.
+- **Collections are smart collections driven by tags**: a product joins
+  collection \`x\` by carrying tag \`collection:x\`, and the collection's
+  \`rule\` is \`{ "tag": "collection:x" }\`. Every product belongs to at
+  least one collection.
+- **Mandatory collections**: \`best-sellers\` and \`sale\`. Sale products
+  carry a real \`compareAtPrice\` AND the \`collection:sale\` tag.
+- \`options\` is 0–3 option names; each variant's \`options\` array matches
+  that length and order. Single-variant products omit \`options\` and give
+  one variant with \`"options": []\`.
+- Prices are strings with 2 decimals, in the store currency. Honest
+  markdowns only (15–25% off typical).
+- Colors and variants get evocative names per brand.md — never "Gray 02".
+
+## images/manifest.json rules
+
+- Three shots per hero product: packshot (\`<handle>.png\`), macro detail
+  (\`<handle>-detail.png\`), lifestyle/model (\`<handle>-model.png\`,
+  \`"type": "model"\`). ~33–36 entries total. Every \`handle\` must exist in
+  catalog.json; every entry needs \`alt\` text.
+- \`style\` prefixes packshot/detail prompts; \`modelStyle\` prefixes
+  \`type: "model"\` prompts. Keep prompts concrete: materials, colors,
+  camera angle, light.
+- **Prompt safety (gpt-image-2 rejects [sexual] otherwise)** — for
+  human-model shots: say "woman"/"man", never "young …"; keep fitted
+  garments layered or covered (blazer / cardigan / cover-up); crop at
+  the chin or shoot from behind; prefer wider framing. Swimwear: show
+  the garment via flat-lay + detail; make the model shot a cover-up
+  scene. Pet/object products: no such constraints.
+
+## Pipeline (after authoring)
+
+\`\`\`sh
+zalify brand validate                  # lint this folder (cwd)
+# create the Shopify dev store + Zalify workspace, then:
+zalify workspace set <workspace-slug>
+zalify site create <slug>              # hosted site: repo + deploy + domain + token
+zalify brand push --prune              # catalog → your Shopify store
+zalify brand images generate           # create the manifest's shots
+zalify brand images attach             # attach them to the products
+\`\`\`
+`;
+var BRAND_MD = (name) => `# ${name} — brand voice guide
+
+## Who we are
+
+<2–3 sentences: what the brand makes, for whom, and the feeling it sells.>
+
+## Audience
+
+<Who buys: age band, habits, what they care about. Name the customer the
+way the brand would ("pet parents", not "owners").>
+
+## Tone
+
+- <3–5 bullets: adjectives with teeth, plus what the brand NEVER sounds like.>
+- <How to address the reader (second person? playful? expert-calm?).>
+
+## Naming conventions
+
+- <Pattern for product names, with 2–3 examples.>
+- <How colors/variants are named (evocative, never "Gray 02").>
+
+## Price band
+
+- <Floor–ceiling and what anchors each end. Markdown policy.>
+
+## Quick sniff test
+
+<One sentence: how to tell a line of copy is (or isn't) this brand.>
+`;
+var STORE_JSON = (name, slug, vertical, currency) => JSON.stringify({
+  name,
+  slug,
+  vertical,
+  currency,
+  storeDomain: null,
+  notes: "Standalone-copy deployment — fill storeDomain when the Shopify dev store exists; no siteUrl on purpose."
+}, null, 2) + `
+`;
+var CATALOG_JSON = (vendor, currency) => JSON.stringify({
+  vendor,
+  currency,
+  products: [
+    {
+      handle: "example-product",
+      title: "The Example Product",
+      descriptionHtml: "<p>Two short paragraphs in the brand voice: lead with the moment the customer uses it, then the practical facts.</p><ul><li>Material / composition</li><li>Care instructions</li><li>Size guidance</li></ul>",
+      type: "Category",
+      tags: ["example", "collection:best-sellers"],
+      options: ["Color"],
+      variants: [
+        {
+          options: ["Oat Cream"],
+          sku: "EXM-001-OAT",
+          price: "29.00",
+          compareAtPrice: null,
+          grams: 500,
+          inventory: 50
+        }
+      ],
+      seo: {
+        title: "The Example Product — Brand",
+        description: "One-sentence meta description in the brand voice."
+      }
+    }
+  ],
+  collections: [
+    {
+      handle: "best-sellers",
+      title: "Best Sellers",
+      descriptionHtml: "<p>The ones everyone comes back for.</p>",
+      rule: { tag: "collection:best-sellers" }
+    },
+    {
+      handle: "sale",
+      title: "Sale",
+      descriptionHtml: "<p>Real markdowns on favorites.</p>",
+      rule: { tag: "collection:sale" }
+    }
+  ]
+}, null, 2) + `
+`;
+var MANIFEST_JSON = JSON.stringify({
+  style: "<shared prefix for packshot/detail prompts: photography style, background, light, 'no text, no watermark. Square 1:1 composition.'>",
+  modelStyle: "<shared prefix for type:'model' lifestyle prompts — scene, mood, framing. Mind the prompt-safety rules in AUTHORING.md for human models.>",
+  images: [
+    {
+      handle: "example-product",
+      file: "example-product.png",
+      alt: "The Example Product in Oat Cream, front three-quarter view",
+      prompt: "<concrete packshot prompt: the product, materials, colors, camera angle>"
+    },
+    {
+      handle: "example-product",
+      file: "example-product-detail.png",
+      alt: "Macro detail of the Example Product's texture",
+      prompt: "<extreme macro close-up prompt: texture, seam, hardware>"
+    },
+    {
+      handle: "example-product",
+      file: "example-product-model.png",
+      type: "model",
+      alt: "The Example Product in use",
+      prompt: "<lifestyle prompt: who/what uses it, where, light>"
+    }
+  ]
+}, null, 2) + `
+`;
+function brandInit(dir2 = ".", opts = {}) {
+  const target = resolve6(dir2);
+  const slug = basename4(target).toLowerCase().replaceAll(/[^a-z0-9-]+/g, "-").replaceAll(/^-+|-+$/g, "");
+  if (existsSync7(target) && readdirSync3(target).length > 0) {
+    throw new Error(`${dir2} already exists and is not empty`);
+  }
+  const name = opts.name ?? slug.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+  const currency = (opts.currency ?? "USD").toUpperCase();
+  mkdirSync3(join7(target, "images"), { recursive: true });
+  writeFileSync7(join7(target, "AUTHORING.md"), AUTHORING_MD);
+  writeFileSync7(join7(target, "brand.md"), BRAND_MD(name));
+  writeFileSync7(join7(target, "store.json"), STORE_JSON(name, slug, opts.vertical ?? "<vertical>", currency));
+  writeFileSync7(join7(target, "catalog.json"), CATALOG_JSON(name, currency));
+  writeFileSync7(join7(target, "images", "manifest.json"), MANIFEST_JSON);
+  console.log(`Scaffolded brand data in ${dir2}:`);
+  for (const f of ["AUTHORING.md", "brand.md", "store.json", "catalog.json", "images/manifest.json"]) {
+    console.log(`  + ${f}`);
+  }
+  console.log(`
+Author in this order: brand.md → catalog.json → images/manifest.json` + `
+(rules + worked examples in AUTHORING.md; lint with \`zalify brand validate ${dir2}\`)`);
+}
+function brandValidate(dir2 = ".") {
+  const target = resolve6(dir2);
+  const problems = [];
+  const warnings = [];
+  const readJson2 = (rel) => {
+    const path9 = join7(target, rel);
+    if (!existsSync7(path9)) {
+      problems.push(`missing ${rel}`);
+      return null;
+    }
+    try {
+      return JSON.parse(readFileSync7(path9, "utf8"));
+    } catch (err) {
+      problems.push(`${rel}: invalid JSON — ${err instanceof Error ? err.message : err}`);
+      return null;
+    }
+  };
+  if (!existsSync7(join7(target, "brand.md")))
+    problems.push("missing brand.md");
+  const store = readJson2("store.json");
+  if (store && (!store.name || !store.slug))
+    problems.push("store.json: name and slug are required");
+  const catalog = readJson2("catalog.json");
+  const handles = new Set;
+  if (catalog) {
+    const products = catalog.products ?? [];
+    if (!products.length)
+      problems.push("catalog.json: no products");
+    if (products.some((p) => p.handle === "example-product")) {
+      warnings.push("catalog.json still contains the example-product stub");
+    }
+    const collectionTags = new Set((catalog.collections ?? []).map((c) => c.rule?.tag).filter(Boolean));
+    for (const c of ["best-sellers", "sale"]) {
+      if (!(catalog.collections ?? []).some((col) => col.handle === c)) {
+        problems.push(`catalog.json: mandatory collection "${c}" missing`);
+      }
+    }
+    for (const p of products) {
+      const where = `product "${p.handle ?? p.title ?? "?"}"`;
+      if (!p.handle || !/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/.test(p.handle)) {
+        problems.push(`${where}: handle must be kebab-case`);
+      } else if (handles.has(p.handle)) {
+        problems.push(`${where}: duplicate handle`);
+      } else {
+        handles.add(p.handle);
+      }
+      if (!p.title || !p.descriptionHtml || !p.type) {
+        problems.push(`${where}: title, descriptionHtml, and type are required`);
+      }
+      const tags = p.tags ?? [];
+      const colTags = tags.filter((t) => t.startsWith("collection:"));
+      if (!colTags.length)
+        problems.push(`${where}: no collection:<handle> tag`);
+      for (const t of colTags) {
+        if (!collectionTags.has(t)) {
+          problems.push(`${where}: tag "${t}" matches no collection rule`);
+        }
+      }
+      const optionCount = p.options?.length ?? 0;
+      if (optionCount > 3)
+        problems.push(`${where}: more than 3 options`);
+      if (!p.variants?.length) {
+        problems.push(`${where}: at least one variant required`);
+      } else {
+        const hasSale = tags.includes("collection:sale");
+        let anyCompareAt = false;
+        for (const v of p.variants) {
+          if ((v.options?.length ?? 0) !== optionCount) {
+            problems.push(`${where}: variant options length must match options (${optionCount})`);
+          }
+          if (!v.price || !/^\d+\.\d{2}$/.test(v.price)) {
+            problems.push(`${where}: price must be a string with 2 decimals`);
+          }
+          if (v.compareAtPrice != null) {
+            anyCompareAt = true;
+            if (!/^\d+\.\d{2}$/.test(v.compareAtPrice)) {
+              problems.push(`${where}: compareAtPrice must be a string with 2 decimals`);
+            } else if (v.price && Number(v.compareAtPrice) <= Number(v.price)) {
+              problems.push(`${where}: compareAtPrice must exceed price`);
+            }
+          }
+        }
+        if (hasSale && !anyCompareAt) {
+          problems.push(`${where}: in collection:sale but no variant has compareAtPrice`);
+        }
+        if (anyCompareAt && !hasSale) {
+          warnings.push(`${where}: has compareAtPrice but not tagged collection:sale`);
+        }
+      }
+    }
+  }
+  const manifest = readJson2("images/manifest.json");
+  if (manifest) {
+    const images = manifest.images ?? [];
+    if (!images.length)
+      problems.push("images/manifest.json: no images");
+    if (!manifest.style || manifest.style.startsWith("<")) {
+      warnings.push("images/manifest.json: style prefix not filled in");
+    }
+    const files = new Set;
+    for (const entry of images) {
+      const where = `image "${entry.file ?? "?"}"`;
+      if (!entry.file || !entry.prompt)
+        problems.push(`${where}: file and prompt required`);
+      if (!entry.alt)
+        problems.push(`${where}: alt text required`);
+      if (entry.file) {
+        if (files.has(entry.file))
+          problems.push(`${where}: duplicate file`);
+        files.add(entry.file);
+      }
+      if (entry.handle && handles.size && !handles.has(entry.handle)) {
+        problems.push(`${where}: handle "${entry.handle}" not in catalog.json`);
+      }
+      if (entry.type === "model" && (!manifest.modelStyle || manifest.modelStyle.startsWith("<"))) {
+        warnings.push("images/manifest.json: modelStyle prefix not filled in (model shots present)");
+      }
+    }
+  }
+  for (const w of [...new Set(warnings)])
+    console.log(`  ! ${w}`);
+  if (problems.length) {
+    for (const p of problems)
+      console.log(`  ✗ ${p}`);
+    throw new Error(`${problems.length} problem(s) — fix and re-run \`zalify brand validate\``);
+  }
+  console.log(`✓ valid: ${handles.size} product(s), ${catalog?.collections?.length ?? 0} collection(s), ${manifest?.images?.length ?? 0} image entries` + (warnings.length ? ` — ${warnings.length} warning(s)` : ""));
 }
 
 // src/cli.ts
 var __dirname4 = dirname2(fileURLToPath3(import.meta.url));
 var require2 = createRequire2(import.meta.url);
-var pkg = require2(join7(__dirname4, "..", "package.json"));
+var pkg = require2(join8(__dirname4, "..", "package.json"));
 try {
   updateNotifier({ pkg }).notify({
     isGlobal: true,
@@ -12921,7 +13295,78 @@ try {
   });
 } catch {}
 var program2 = new Command;
-program2.name("zalify").description("Zalify CLI - command-line interface for Zalify").version(pkg.version, "-v, --version", "output the current version");
+program2.name("zalify").description("Zalify CLI — author a brand, launch its site, keep the theme current").version(pkg.version, "-v, --version", "output the current version");
+program2.addHelpText("after", `
+The golden path (new brand, start to live):
+  1. zalify brand init stores/acme        author the data (no login needed)
+  2. zalify login && zalify workspace set <workspace>
+  3. zalify site create acme              repo + hosting + domain + deploy
+  4. cd stores/acme && zalify brand push --prune
+  5. zalify brand images generate && zalify brand images attach
+  6. zalify theme status | upgrade        stay current, keep your edits
+`);
+var moved = (to) => console.log(`(moved — this is now \`zalify ${to}\`)`);
+program2.command("login").description("Authenticate via the browser (one login covers all your workspaces)").option("--app-url <url>", "Zalify app origin (default: https://app.zalify.com)").action(async (options) => {
+  await login(options);
+});
+program2.command("logout").description("Delete the stored CLI credentials").action(() => logout());
+program2.command("whoami").description("Verify the stored key and show workspace, plan, and key details").action(async () => {
+  await whoami();
+});
+var workspace = program2.command("workspace").description("Active workspace — which Shopify store your commands target");
+workspace.command("list", { isDefault: true }).description("List authorized workspaces (* = active)").action(async () => {
+  await workspaceList();
+});
+workspace.command("set <slug-or-id>").description("Switch the active workspace (local, no re-login)").action(async (slugOrId) => {
+  await workspaceSet(slugOrId);
+});
+var brand = program2.command("brand").description("Brand data — author the catalog, voice, and imagery; push it to your Shopify store");
+brand.command("init [dir]").description("Scaffold a brand folder (catalog, voice guide, image manifest + AUTHORING.md rules); no login needed").option("--name <name>", "brand name (default: derived from the directory)").option("--vertical <vertical>", "e.g. womens-fast-fashion, pet-supplies").option("--currency <code>", "ISO currency", "USD").action((dir2, options) => {
+  brandInit(dir2, options);
+});
+brand.command("validate [dir]").description("Lint the brand folder against the authoring rules").action((dir2) => {
+  brandValidate(dir2);
+});
+brand.command("push [dir]").description("Push catalog.json to your connected Shopify store (products, smart collections, publish; idempotent)").option("--prune", "delete store products (by catalog vendor) absent from catalog.json").option("--site <slug>", "refresh only this site afterwards (default: every site matching the brand)").action(async (dir2, options) => {
+  await shopifyImport(dir2 ?? ".", options);
+});
+var brandImages = brand.command("images").description("The brand's imagery pipeline: generate → attach → push/pull masters");
+brandImages.command("generate [dir]").description("Generate the manifest's missing images on Zalify infrastructure (resumable)").action(async (dir2) => {
+  await imagesGenerate(dir2 ?? ".");
+});
+brandImages.command("attach [dir]").description("Attach generated images to their Shopify products per the manifest (skips already-attached)").option("--site <slug>", "refresh only this site afterwards").action(async (dir2, options) => {
+  await shopifyUploadImages(dir2 ?? ".", options);
+});
+brandImages.command("push [dir]").description("Upload image masters to the Zalify asset library (sha256 dedup, writes assets.json)").action(async (dir2) => {
+  await assetsPush(dir2 ?? ".");
+});
+brandImages.command("pull [dir]").description("Download masters listed in images/assets.json (fresh-clone restore)").action(async (dir2) => {
+  await assetsPull(dir2 ?? ".");
+});
+var site = program2.command("site").description("Hosted sites — Zalify provisions the repo, deployment, and domain");
+site.command("create <dir>").description("One-command launch: provision repo + deployment + domain + storefront token, scaffold locally, push, go live").option("-t, --theme <name>", "theme", "nextjs").option("--editor", "include the Zalify canvas-editor (z1) wiring").option("--to <version>", "theme version (default: latest)").option("--no-install", "skip dependency install").option("--no-git", "skip git init/push").action(async (dir2, options) => {
+  await siteCreate(dir2, options);
+});
+site.command("list", { isDefault: true }).description("List the workspace's hosted sites").action(async () => {
+  await siteList();
+});
+site.command("refresh [slug-or-dir]").description("Refresh the live site's data cache (defaults to the site linked to cwd)").action(async (slugOrDir) => {
+  await siteRefresh(slugOrDir);
+});
+site.command("open [slug-or-dir]").description("Open the live site in your browser (defaults to the site linked to cwd)").action(async (slugOrDir) => {
+  await siteOpen(slugOrDir);
+});
+var theme = program2.command("theme").description("Theme source code — scaffold a copy and upgrade it without losing your edits");
+theme.command("create <dir>").description("Scaffold only — no Zalify hosting (self-host path; `site create` is the fully-hosted launch)").option("-t, --template <name>", "liquid | hydrogen | nextjs", "nextjs").option("--editor", "include the Zalify canvas-editor (z1) wiring").option("--store-domain <domain>", "your-store.myshopify.com (default: mock.shop demo data)").option("--storefront-token <token>", "public Storefront API access token").option("--to <version>", "theme version (default: latest)").option("--no-install", "skip dependency install").option("--no-git", "skip git init + initial commit").option("--tarball <path>", "use a local @zalify/theme-templates .tgz instead of npm").action(async (dir2, options) => {
+  await themeCreate(dir2, options);
+});
+theme.command("status [dir]").description("Which theme files have you edited? (checksums vs .zalify/theme.json)").action((dir2) => {
+  themeStatus(dir2);
+});
+theme.command("upgrade [dir]").description("Move to a newer theme version: untouched files overwritten, edited files 3-way-merged, theme/ + .env never touched").option("--to <version>", "target theme version (default: latest)").option("--dry-run", "classify and report without writing anything").option("--install", "run install when dependencies changed").option("--tarball <path>", "target version as a local .tgz (testing)").option("--base-tarball <path>", "base version as a local .tgz (testing)").action(async (dir2, options) => {
+  await themeUpgrade(dir2, options);
+});
+program2.command("self-update").description("Update the CLI to the latest version (auto-detects pnpm/bun/npm)").action(() => selfUpdate(pkg.version));
 program2.command("version").description("Print Zalify CLI version and check for updates").action(async () => {
   console.log(`Zalify CLI version: ${pkg.version}`);
   const isNewer = (a, b) => {
@@ -12938,62 +13383,54 @@ program2.command("version").description("Print Zalify CLI version and check for
     const update = await notifier.fetchInfo();
     if (update && isNewer(update.latest, update.current)) {
       console.log(`
-A new version (${update.latest}) is available. Run "npm i -g @zalify/cli@latest" to update.`);
+A new version (${update.latest}) is available. Run "zalify self-update" to update.`);
     }
   } catch {}
 });
-program2.command("self-update").description("Update the CLI to the latest version (auto-detects pnpm/bun/npm)").action(() => selfUpdate(pkg.version));
-program2.command("login").description("Authenticate via the browser and store a workspace API key").option("--app-url <url>", "Zalify app origin (default: https://app.zalify.com)").action(async (options) => {
-  await login(options);
+var legacyStore = program2.command("store", { hidden: true });
+legacyStore.command("init <dir>").option("--name <name>").option("--vertical <vertical>").option("--currency <code>").action((dir2, options) => {
+  moved("brand init");
+  brandInit(dir2, options);
 });
-program2.command("logout").description("Delete the stored CLI credentials").action(() => logout());
-program2.command("whoami").description("Verify the stored key and show workspace, plan, and key details").action(async () => {
-  await whoami();
+legacyStore.command("validate <dir>").action((dir2) => {
+  moved("brand validate");
+  brandValidate(dir2);
 });
-var workspace = program2.command("workspace").description("List authorized workspaces or switch the active one");
-workspace.command("list", { isDefault: true }).description("List authorized workspaces (* = active)").action(async () => {
-  await workspaceList();
-});
-workspace.command("set <slug-or-id>").description("Switch the active workspace (local, no re-login)").action(async (slugOrId) => {
-  await workspaceSet(slugOrId);
-});
-var images = program2.command("images").description("Generate images on Zalify infrastructure");
-images.command("generate <store-dir>").description("Generate missing manifest images server-side (results land in the asset library and are downloaded locally)").action(async (storeDir) => {
-  await imagesGenerate(storeDir);
-});
-var shopify = program2.command("shopify").description("Push catalogs and images to the workspace's connected Shopify store");
-shopify.command("import <store-dir>").description("Import <store-dir>/catalog.json into the connected Shopify store (products, smart collections, Online Store publish; idempotent by handle)").option("--prune", "delete store products (by catalog vendor) absent from catalog.json").action(async (storeDir, options) => {
+var legacyShopify = program2.command("shopify", { hidden: true });
+legacyShopify.command("import <store-dir>").option("--prune").action(async (storeDir, options) => {
+  moved("brand push");
   await shopifyImport(storeDir, options);
 });
-shopify.command("upload-images <store-dir>").description("Upload <store-dir>/images/* to matching products per images/manifest.json (skips files already attached)").action(async (storeDir) => {
+legacyShopify.command("upload-images <store-dir>").action(async (storeDir) => {
+  moved("brand images attach");
   await shopifyUploadImages(storeDir);
 });
-var storefront = program2.command("storefront").description("Provision and manage fully-hosted standalone storefronts (repo + Vercel via Zalify)");
-storefront.command("create <dir>").description("One-command launch: Zalify provisions the GitHub repo + Vercel project (env, domain, storefront token), then scaffolds locally and pushes").option("-t, --theme <name>", "theme", "nextjs").option("--editor", "include the Zalify canvas-editor (z1) wiring").option("--to <version>", "template version (default: latest)").option("--no-install", "skip dependency install").option("--no-git", "skip git init/push").action(async (dir2, options) => {
-  await storefrontCreate(dir2, options);
-});
-storefront.command("list", { isDefault: true }).description("List the workspace's provisioned storefronts").action(async () => {
-  await storefrontList();
-});
-storefront.command("revalidate <slug-or-store-dir>").description("Flush the storefront site's data cache (secret stays server-side)").action(async (slugOrDir) => {
-  await storefrontRevalidate(slugOrDir);
+var legacyImages = program2.command("images", { hidden: true });
+legacyImages.command("generate <store-dir>").action(async (storeDir) => {
+  moved("brand images generate");
+  await imagesGenerate(storeDir);
 });
-var theme = program2.command("theme").description("Scaffold and upgrade standalone Zalify storefronts (Shopify-theme model)");
-theme.command("create <dir>").description("Scaffold a standalone storefront from the published theme templates").option("-t, --template <name>", "liquid | hydrogen | nextjs", "nextjs").option("--editor", "include the Zalify canvas-editor (z1) wiring").option("--store-domain <domain>", "your-store.myshopify.com (default: mock.shop demo data)").option("--storefront-token <token>", "public Storefront API access token").option("--to <version>", "template version (default: latest)").option("--no-install", "skip dependency install").option("--no-git", "skip git init + initial commit").option("--tarball <path>", "use a local @zalify/theme-templates .tgz instead of npm").action(async (dir2, options) => {
-  await themeCreate(dir2, options);
+var legacyAssets = program2.command("assets", { hidden: true });
+legacyAssets.command("push <store-dir>").action(async (storeDir) => {
+  moved("brand images push");
+  await assetsPush(storeDir);
 });
-theme.command("status [dir]").description("List theme-owned files edited since scaffolding (.zalify/theme.json checksums)").action((dir2) => {
-  themeStatus(dir2);
+legacyAssets.command("pull <store-dir>").action(async (storeDir) => {
+  moved("brand images pull");
+  await assetsPull(storeDir);
 });
-theme.command("upgrade [dir]").description("Upgrade to a newer theme version: untouched files overwritten, edited files 3-way-merged, theme/ + .env never touched").option("--to <version>", "target template version (default: latest)").option("--dry-run", "classify and report without writing anything").option("--install", "run install when dependencies changed").option("--tarball <path>", "target version as a local .tgz (testing)").option("--base-tarball <path>", "base version as a local .tgz (testing)").action(async (dir2, options) => {
-  await themeUpgrade(dir2, options);
+var legacyStorefront = program2.command("storefront", { hidden: true });
+legacyStorefront.command("create <dir>").option("-t, --theme <name>", "", "nextjs").option("--editor").option("--to <version>").option("--no-install").option("--no-git").action(async (dir2, options) => {
+  moved("site create");
+  await siteCreate(dir2, options);
 });
-var assets = program2.command("assets").description("Sync images with the Zalify asset library");
-assets.command("push <store-dir>").description("Upload <store-dir>/images/*.png (sha256 dedup, writes assets.json)").action(async (storeDir) => {
-  await assetsPush(storeDir);
+legacyStorefront.command("list", { isDefault: true }).action(async () => {
+  moved("site list");
+  await siteList();
 });
-assets.command("pull <store-dir>").description("Download files listed in <store-dir>/images/assets.json").action(async (storeDir) => {
-  await assetsPull(storeDir);
+legacyStorefront.command("revalidate <slug-or-store-dir>").action(async (slugOrDir) => {
+  moved("site refresh");
+  await siteRefresh(slugOrDir);
 });
 program2.parseAsync().catch((err) => {
   console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zalify/cli",
-  "version": "0.9.1",
+  "version": "0.11.0",
   "description": "Zalify CLI - command-line interface for Zalify",
   "type": "module",
   "main": "dist/cli.js",