brandspec 0.1.0

package/dist/cli.js

@@ -0,0 +1,1516 @@
+#!/usr/bin/env node
+
+// cli/cli.ts
+import {
+  readFileSync as readFileSync2,
+  writeFileSync as writeFileSync2,
+  existsSync as existsSync2,
+  statSync,
+  mkdirSync as mkdirSync2,
+  cpSync,
+  readdirSync,
+  unlinkSync
+} from "fs";
+import { resolve as resolve2, dirname as dirname2, join as join2 } from "path";
+import { fileURLToPath } from "url";
+import { createInterface } from "readline";
+
+// cli/parser.ts
+import yaml from "js-yaml";
+function parse(content) {
+  const errors = [];
+  const warnings = [];
+  let parsed;
+  try {
+    parsed = yaml.load(content);
+  } catch (e) {
+    return {
+      success: false,
+      errors: [`Invalid YAML: ${e instanceof Error ? e.message : "Unknown error"}`],
+      warnings: []
+    };
+  }
+  if (!parsed || typeof parsed !== "object") {
+    return { success: false, errors: ["YAML must be an object"], warnings: [] };
+  }
+  const doc = parsed;
+  if (!doc.meta || typeof doc.meta !== "object") {
+    errors.push("Missing required field: meta");
+    return { success: false, errors, warnings };
+  }
+  const meta = doc.meta;
+  if (!meta.name || typeof meta.name !== "string") {
+    errors.push("Missing required field: meta.name");
+    return { success: false, errors, warnings };
+  }
+  if (doc.assets !== void 0) {
+    if (!Array.isArray(doc.assets)) {
+      errors.push("Field 'assets' must be an array");
+    } else {
+      doc.assets.forEach((asset, i) => {
+        if (!asset || typeof asset !== "object") {
+          errors.push(`assets[${i}] must be an object`);
+        } else {
+          const a = asset;
+          if (!a.file || typeof a.file !== "string") {
+            errors.push(`assets[${i}].file is required and must be a string`);
+          }
+        }
+      });
+    }
+  }
+  if (!doc.core) {
+    warnings.push("No 'core' section \u2014 brand essence, personality, and voice are recommended");
+  }
+  if (!doc.tokens) {
+    warnings.push("No 'tokens' section \u2014 design tokens are recommended");
+  }
+  if (errors.length > 0) {
+    return { success: false, errors, warnings };
+  }
+  return {
+    success: true,
+    data: doc,
+    errors: [],
+    warnings
+  };
+}
+
+// cli/validate.ts
+import Ajv from "ajv";
+import addFormats from "ajv-formats";
+
+// cli/schema.ts
+var schema = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://brandspec.tools/schema/v0.1.0",
+  title: "brandspec",
+  description: "Brand Identity specification format",
+  type: "object",
+  required: ["meta"],
+  properties: {
+    meta: {
+      type: "object",
+      description: "Brand metadata",
+      required: ["name"],
+      properties: {
+        name: { type: "string", description: "Brand name" },
+        version: { type: "string", description: "Brand spec version (semver)" },
+        updated: { type: "string", format: "date", description: "Last updated date" },
+        description: { type: "string", description: "Brief brand description" },
+        url: { type: "string", format: "uri", description: "Brand website" }
+      },
+      additionalProperties: true
+    },
+    core: {
+      type: "object",
+      description: "Brand essence, personality, and voice",
+      properties: {
+        essence: { type: "string" },
+        tagline: { type: "string" },
+        mission: { type: "string" },
+        vision: { type: "string" },
+        values: { type: "array", items: { type: "string" } },
+        personality: { type: "array", items: { type: "string" } },
+        voice: {
+          type: "object",
+          properties: {
+            tone: { type: "array", items: { type: "string" } },
+            principles: { type: "array", items: { type: "string" } }
+          },
+          additionalProperties: true
+        }
+      },
+      additionalProperties: true
+    },
+    tokens: {
+      type: "object",
+      description: "Design tokens (W3C DTCG compliant)",
+      additionalProperties: true
+    },
+    assets: {
+      type: "array",
+      description: "Brand assets",
+      items: {
+        type: "object",
+        required: ["file"],
+        properties: {
+          file: { type: "string" },
+          id: { type: "string" },
+          role: { type: "string" },
+          variant: { type: "string" },
+          context: { type: "string" },
+          description: { type: "string" },
+          formats: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                path: { type: "string" },
+                width: { type: "integer" },
+                height: { type: "integer" }
+              },
+              additionalProperties: true
+            }
+          },
+          tags: { type: "array", items: { type: "string" } }
+        },
+        additionalProperties: true
+      }
+    },
+    guidelines: {
+      type: "object",
+      description: "Usage guidelines",
+      additionalProperties: {
+        type: "object",
+        properties: {
+          content: { type: "string" },
+          rules: {
+            type: "array",
+            items: { $ref: "#/$defs/guidelineRule" }
+          }
+        },
+        additionalProperties: true
+      }
+    },
+    extensions: {
+      type: "object",
+      description: "Custom extensions",
+      additionalProperties: true
+    }
+  },
+  additionalProperties: true,
+  $defs: {
+    guidelineRule: {
+      type: "object",
+      required: ["description", "severity"],
+      properties: {
+        id: { type: "string" },
+        description: { type: "string" },
+        severity: {
+          type: "string",
+          enum: ["info", "warning", "error"]
+        },
+        criteria: { type: "array", items: { type: "string" } },
+        applies_to: { type: "string" }
+      },
+      additionalProperties: true
+    }
+  }
+};
+
+// cli/validate.ts
+var ajvInstance = null;
+function getAjv() {
+  if (!ajvInstance) {
+    ajvInstance = new Ajv({ allErrors: true, strict: false });
+    addFormats(ajvInstance);
+  }
+  return ajvInstance;
+}
+function validate(data) {
+  const ajv = getAjv();
+  const { $schema: _, $id: __, ...schemaBody } = schema;
+  const valid = ajv.validate(schemaBody, data);
+  if (valid) {
+    return { valid: true, errors: [], warnings: [] };
+  }
+  const errors = (ajv.errors ?? []).map((err) => {
+    const path = err.instancePath || "/";
+    return `${path}: ${err.message}`;
+  });
+  return { valid: false, errors, warnings: [] };
+}
+
+// cli/color.ts
+function parseColor(color2) {
+  const hex = color2.match(/^#([0-9a-f]{3,8})$/i);
+  if (hex) {
+    let h = hex[1];
+    if (h.length === 3) h = h[0] + h[0] + h[1] + h[1] + h[2] + h[2];
+    return [
+      parseInt(h.slice(0, 2), 16),
+      parseInt(h.slice(2, 4), 16),
+      parseInt(h.slice(4, 6), 16)
+    ];
+  }
+  const rgb = color2.match(/^rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)/);
+  if (rgb) {
+    return [parseInt(rgb[1]), parseInt(rgb[2]), parseInt(rgb[3])];
+  }
+  const oklch = color2.match(
+    /oklch\(\s*([\d.]+)(%?)\s+([\d.]+)\s+([\d.]+)/
+  );
+  if (oklch) {
+    const L = oklch[2] === "%" ? parseFloat(oklch[1]) / 100 : parseFloat(oklch[1]);
+    const C = parseFloat(oklch[3]);
+    const H = parseFloat(oklch[4]);
+    return oklchToSrgb(L, C, H);
+  }
+  return null;
+}
+function oklchToSrgb(L, C, H) {
+  const hRad = H * Math.PI / 180;
+  const a = C * Math.cos(hRad);
+  const b = C * Math.sin(hRad);
+  const l_ = L + 0.3963377774 * a + 0.2158037573 * b;
+  const m_ = L - 0.1055613458 * a - 0.0638541728 * b;
+  const s_ = L - 0.0894841775 * a - 1.291485548 * b;
+  const l = l_ * l_ * l_;
+  const m = m_ * m_ * m_;
+  const s = s_ * s_ * s_;
+  const rl = 4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s;
+  const gl = -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s;
+  const bl = -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s;
+  const gamma = (x) => x <= 31308e-7 ? 12.92 * x : 1.055 * Math.pow(x, 1 / 2.4) - 0.055;
+  const clamp = (x) => Math.max(0, Math.min(255, Math.round(x * 255)));
+  return [clamp(gamma(rl)), clamp(gamma(gl)), clamp(gamma(bl))];
+}
+function relativeLuminance(r, g, b) {
+  const [rs, gs, bs] = [r, g, b].map((c) => {
+    const s = c / 255;
+    return s <= 0.03928 ? s / 12.92 : Math.pow((s + 0.055) / 1.055, 2.4);
+  });
+  return 0.2126 * rs + 0.7152 * gs + 0.0722 * bs;
+}
+function getContrastRatio(color1, color2) {
+  const c1 = parseColor(color1);
+  const c2 = parseColor(color2);
+  if (!c1 || !c2) return 21;
+  const l1 = relativeLuminance(...c1);
+  const l2 = relativeLuminance(...c2);
+  const lighter = Math.max(l1, l2);
+  const darker = Math.min(l1, l2);
+  return (lighter + 0.05) / (darker + 0.05);
+}
+function findColorValue(colors, name) {
+  const token = colors[name];
+  if (isToken(token)) return token.$value;
+  if (typeof token === "object" && token !== null) {
+    const nested = token;
+    if (isToken(nested)) return nested.$value;
+  }
+  return null;
+}
+function isToken(v) {
+  return typeof v === "object" && v !== null && "$value" in v;
+}
+
+// cli/lint.ts
+var requiredFields = (spec) => {
+  const results = [];
+  if (!spec.meta.version) {
+    results.push({
+      rule: "meta/version-required",
+      severity: "warning",
+      message: "meta.version is recommended for tracking changes",
+      path: "meta.version"
+    });
+  }
+  if (!spec.core) {
+    results.push({
+      rule: "core/missing",
+      severity: "warning",
+      message: "core section is missing \u2014 brand identity is undefined",
+      path: "core"
+    });
+  } else {
+    if (!spec.core.essence && !spec.core.tagline) {
+      results.push({
+        rule: "core/identity-missing",
+        severity: "warning",
+        message: "Neither essence nor tagline is defined",
+        path: "core"
+      });
+    }
+    if (!spec.core.personality || spec.core.personality.length === 0) {
+      results.push({
+        rule: "core/personality-empty",
+        severity: "info",
+        message: "No personality traits defined",
+        path: "core.personality"
+      });
+    }
+    if (!spec.core.voice) {
+      results.push({
+        rule: "core/voice-missing",
+        severity: "info",
+        message: "Voice guidelines not defined",
+        path: "core.voice"
+      });
+    }
+  }
+  if (!spec.tokens) {
+    results.push({
+      rule: "tokens/missing",
+      severity: "warning",
+      message: "No design tokens defined",
+      path: "tokens"
+    });
+  } else {
+    if (!spec.tokens.colors || Object.keys(spec.tokens.colors).length === 0) {
+      results.push({
+        rule: "tokens/colors-empty",
+        severity: "warning",
+        message: "No color tokens defined",
+        path: "tokens.colors"
+      });
+    }
+    if (!spec.tokens.typography || Object.keys(spec.tokens.typography).length === 0) {
+      results.push({
+        rule: "tokens/typography-empty",
+        severity: "info",
+        message: "No typography tokens defined",
+        path: "tokens.typography"
+      });
+    }
+  }
+  return results;
+};
+var colorContrast = (spec) => {
+  var _a;
+  const results = [];
+  const colors = (_a = spec.tokens) == null ? void 0 : _a.colors;
+  if (!colors) return results;
+  const bg = findColorValue(colors, "background");
+  const fg = findColorValue(colors, "foreground");
+  if (bg && fg) {
+    const ratio = getContrastRatio(bg, fg);
+    if (ratio < 4.5) {
+      results.push({
+        rule: "contrast/bg-fg-aa",
+        severity: "error",
+        message: `Background/foreground contrast ratio is ${ratio.toFixed(1)}:1 (WCAG AA requires 4.5:1)`,
+        path: "tokens.colors"
+      });
+    } else if (ratio < 7) {
+      results.push({
+        rule: "contrast/bg-fg-aaa",
+        severity: "info",
+        message: `Background/foreground contrast ratio is ${ratio.toFixed(1)}:1 (WCAG AAA requires 7:1)`,
+        path: "tokens.colors"
+      });
+    }
+  }
+  const primary = findColorValue(colors, "primary");
+  if (primary && bg) {
+    const ratio = getContrastRatio(bg, primary);
+    if (ratio < 3) {
+      results.push({
+        rule: "contrast/primary-bg",
+        severity: "warning",
+        message: `Primary on background contrast ratio is ${ratio.toFixed(1)}:1 (minimum 3:1 for large text)`,
+        path: "tokens.colors.primary"
+      });
+    }
+  }
+  return results;
+};
+var ASSET_PATTERN = /^[a-z0-9]+(-[a-z0-9]+)*(\.[a-z0-9]+)+$/;
+var assetNaming = (spec) => {
+  const results = [];
+  if (!spec.assets) return results;
+  for (const asset of spec.assets) {
+    const fileName = asset.file.split("/").pop() ?? asset.file;
+    if (!ASSET_PATTERN.test(fileName)) {
+      results.push({
+        rule: "assets/naming-convention",
+        severity: "warning",
+        message: `Asset "${asset.file}" doesn't follow {role}-{variant}.{ext} naming convention`,
+        path: "assets"
+      });
+    }
+    if (!asset.role) {
+      results.push({
+        rule: "assets/role-missing",
+        severity: "info",
+        message: `Asset "${asset.file}" has no role defined`,
+        path: "assets"
+      });
+    }
+  }
+  return results;
+};
+var KEBAB_CASE = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+var tokenNaming = (spec) => {
+  const results = [];
+  if (!spec.tokens) return results;
+  for (const [group, tokens] of Object.entries(spec.tokens)) {
+    if (!tokens || typeof tokens !== "object") continue;
+    for (const name of Object.keys(tokens)) {
+      if (name.startsWith("$")) continue;
+      if (!KEBAB_CASE.test(name)) {
+        results.push({
+          rule: "tokens/naming-kebab",
+          severity: "info",
+          message: `Token "${group}.${name}" should use kebab-case`,
+          path: `tokens.${group}.${name}`
+        });
+      }
+    }
+  }
+  return results;
+};
+var essentialColors = (spec) => {
+  var _a;
+  const results = [];
+  const colors = (_a = spec.tokens) == null ? void 0 : _a.colors;
+  if (!colors) return results;
+  const essential = ["primary", "background", "foreground"];
+  for (const name of essential) {
+    if (!findColorValue(colors, name)) {
+      results.push({
+        rule: "tokens/essential-color",
+        severity: "warning",
+        message: `Essential color token "${name}" is missing`,
+        path: `tokens.colors.${name}`
+      });
+    }
+  }
+  return results;
+};
+var ALL_RULES = [
+  requiredFields,
+  colorContrast,
+  assetNaming,
+  tokenNaming,
+  essentialColors
+];
+function lintBrandspec(spec) {
+  const results = ALL_RULES.flatMap((rule) => rule(spec));
+  const errors = results.filter((r) => r.severity === "error").length;
+  const warnings = results.filter((r) => r.severity === "warning").length;
+  const infos = results.filter((r) => r.severity === "info").length;
+  const score = Math.max(
+    0,
+    Math.min(100, 100 - errors * 10 - warnings * 3 - infos)
+  );
+  return { score, results, errors, warnings, infos };
+}
+
+// cli/tokens.ts
+function toCss(data) {
+  var _a;
+  const lines = [];
+  if (!data.tokens) return ":root {}\n";
+  for (const [group, tokens] of Object.entries(data.tokens)) {
+    if (!tokens) continue;
+    for (const [name, token] of Object.entries(tokens)) {
+      const prefix = group === "colors" ? "" : `${group}-`;
+      const varName = `--${prefix}${name}`;
+      lines.push(`  ${varName}: ${token.$value};`);
+    }
+  }
+  const darkLines = [];
+  if (data.tokens.colors) {
+    for (const [name, token] of Object.entries(data.tokens.colors)) {
+      const dark = (_a = token.$extensions) == null ? void 0 : _a["dark"];
+      if (typeof dark === "string") {
+        darkLines.push(`  --${name}: ${dark};`);
+      }
+    }
+  }
+  let output = `:root {
+${lines.join("\n")}
+}
+`;
+  if (darkLines.length > 0) {
+    output += `
+.dark {
+${darkLines.join("\n")}
+}
+`;
+  }
+  return output;
+}
+function toTailwindCss(data) {
+  const lines = [];
+  if (!data.tokens) return '@import "tailwindcss";\n\n@theme {}\n';
+  if (data.tokens.colors) {
+    for (const [name, token] of Object.entries(data.tokens.colors)) {
+      lines.push(`  --color-${name}: ${token.$value};`);
+    }
+  }
+  if (data.tokens.typography) {
+    for (const [name, token] of Object.entries(data.tokens.typography)) {
+      lines.push(`  --font-${name}: ${token.$value};`);
+    }
+  }
+  if (data.tokens.spacing) {
+    for (const [name, token] of Object.entries(data.tokens.spacing)) {
+      lines.push(`  --spacing-${name}: ${token.$value};`);
+    }
+  }
+  if (data.tokens.radius) {
+    for (const [name, token] of Object.entries(data.tokens.radius)) {
+      lines.push(`  --radius-${name}: ${token.$value};`);
+    }
+  }
+  return `@import "tailwindcss";
+
+@theme {
+${lines.join("\n")}
+}
+`;
+}
+function toFigmaTokens(data) {
+  if (!data.tokens) return JSON.stringify({}, null, 2);
+  const output = {};
+  for (const [group, tokens] of Object.entries(data.tokens)) {
+    if (!tokens) continue;
+    output[group] = {};
+    for (const [name, token] of Object.entries(tokens)) {
+      output[group][name] = {
+        value: token.$value,
+        type: token.$type ?? group,
+        ...token.$description && { description: token.$description }
+      };
+    }
+  }
+  return JSON.stringify(output, null, 2) + "\n";
+}
+function toStyleDictionary(data) {
+  const tokenFile = {};
+  if (data.tokens) {
+    for (const [group, tokens2] of Object.entries(data.tokens)) {
+      if (!tokens2) continue;
+      tokenFile[group] = {};
+      for (const [name, token] of Object.entries(tokens2)) {
+        tokenFile[group][name] = {
+          $value: token.$value,
+          $type: token.$type ?? group,
+          ...token.$description && { $description: token.$description }
+        };
+      }
+    }
+  }
+  const tokens = JSON.stringify(tokenFile, null, 2) + "\n";
+  const brandName = data.meta.name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+  const config = {
+    source: ["tokens.json"],
+    usesDtcg: true,
+    platforms: {
+      css: {
+        transformGroup: "css",
+        buildPath: `build/css/`,
+        files: [
+          {
+            destination: "variables.css",
+            format: "css/variables",
+            options: { outputReferences: true }
+          }
+        ]
+      },
+      scss: {
+        transformGroup: "scss",
+        buildPath: `build/scss/`,
+        files: [
+          {
+            destination: "_variables.scss",
+            format: "scss/variables",
+            options: { outputReferences: true }
+          }
+        ]
+      },
+      ios: {
+        transformGroup: "ios-swift",
+        buildPath: `build/ios/`,
+        files: [
+          {
+            destination: `${brandName}.swift`,
+            format: "ios-swift/class.swift",
+            className: data.meta.name.replace(/[^a-zA-Z0-9]/g, "")
+          }
+        ]
+      },
+      android: {
+        transformGroup: "android",
+        buildPath: `build/android/`,
+        files: [
+          {
+            destination: "colors.xml",
+            format: "android/resources",
+            filter: { $type: "color" }
+          },
+          {
+            destination: "dimens.xml",
+            format: "android/resources",
+            filter: { $type: "dimension" }
+          }
+        ]
+      }
+    }
+  };
+  return { tokens, config: JSON.stringify(config, null, 2) + "\n" };
+}
+
+// cli/remote.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { resolve, dirname, join } from "path";
+import { homedir } from "os";
+var API_BASE = process.env.BRANDSPEC_API_URL ?? "https://brandspec.tools";
+function getCredentialsPath() {
+  return join(homedir(), ".config", "brandspec", "credentials");
+}
+function loadToken() {
+  const envToken = process.env.BRANDSPEC_TOKEN;
+  if (envToken) return envToken;
+  const credPath = getCredentialsPath();
+  if (existsSync(credPath)) {
+    const content = readFileSync(credPath, "utf-8").trim();
+    if (content) return content;
+  }
+  return null;
+}
+function parseOrgBrand(str) {
+  const parts = str.split("/");
+  if (parts.length !== 2) return null;
+  const [org, brand] = parts;
+  const slugRe = /^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]$/;
+  if (!slugRe.test(org) || !slugRe.test(brand)) return null;
+  return { org, brand };
+}
+function loadRemote(args) {
+  const positional = args.find((a) => !a.startsWith("-") && a.includes("/"));
+  if (positional) return parseOrgBrand(positional);
+  const rcPath = resolve(".brandspecrc");
+  if (existsSync(rcPath)) {
+    const content = readFileSync(rcPath, "utf-8");
+    const match = content.match(/remote:\s*(.+)/);
+    if (match) return parseOrgBrand(match[1].trim());
+  }
+  return null;
+}
+function ensureBrandspecrc(org, brand) {
+  const rcPath = resolve(".brandspecrc");
+  if (!existsSync(rcPath)) {
+    writeFileSync(rcPath, `remote: ${org}/${brand}
+`, "utf-8");
+  }
+}
+function saveCredentials(token) {
+  const credPath = getCredentialsPath();
+  mkdirSync(dirname(credPath), { recursive: true });
+  writeFileSync(credPath, token, { mode: 384 });
+}
+
+// cli/cli.ts
+var VERSION = "0.1.0";
+function color(code, text) {
+  if (process.env.NO_COLOR || !process.stdout.isTTY) return text;
+  return `\x1B[${code}m${text}\x1B[0m`;
+}
+var green = (t) => color("32", t);
+var yellow = (t) => color("33", t);
+var red = (t) => color("31", t);
+var dim = (t) => color("2", t);
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname2(__filename);
+function requireToken() {
+  const token = loadToken();
+  if (!token) {
+    console.error("Not logged in. Run 'brandspec login' first or set BRANDSPEC_TOKEN.");
+    process.exit(1);
+  }
+  return token;
+}
+function requireRemote(args) {
+  const remote = loadRemote(args);
+  if (!remote) {
+    console.error("No remote specified. Use 'brandspec push org/brand' or create .brandspecrc.");
+    process.exit(1);
+  }
+  return remote;
+}
+var HELP = `
+brandspec v${VERSION}
+Define Brand Identity as code.
+
+Usage:
+  brandspec                Lint brand.yaml in current directory
+  brandspec <command> [options]
+
+Commands:
+  init              Create a brandspec/ directory with templates
+  lint [path]       Lint a brand.yaml (validate + rules + score)
+    --json           Output as JSON (for CI/pipe)
+    --quiet          Exit code only, no output
+  validate [path]   Alias for lint
+  generate [path]   Generate token files from brand.yaml
+    --format <fmt>   css, tailwind, figma, sd, all (comma-separated)
+    --out <dir>      Output directory (default: output/ next to brand.yaml)
+
+  consult [path]          Print brand context for AI consultation
+
+  workshop start          Print start prompt for AI workshop
+  workshop resume         Print resume prompt for AI workshop
+  workshop status         Show current workshop position
+
+  login             Save API token for brandspec.tools
+  logout            Remove saved API token
+  pull [org/brand]  Pull brand from brandspec.tools
+    --no-workshop    Exclude _workshop/ files
+  push [org/brand]  Push brand to brandspec.tools
+
+Options:
+  --help, -h       Show this help
+  --version, -v    Show version
+`.trim();
+var MINIMAL_TEMPLATE = {
+  meta: {
+    name: "My Brand",
+    version: "0.1.0",
+    updated: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
+  },
+  core: {
+    essence: "",
+    tagline: "",
+    personality: [],
+    voice: {
+      tone: [],
+      principles: []
+    }
+  },
+  tokens: {
+    colors: {
+      primary: {
+        $value: "oklch(0.65 0.18 250)",
+        $type: "color",
+        $description: "Primary brand color"
+      },
+      "primary-foreground": {
+        $value: "oklch(0.98 0.01 250)",
+        $type: "color"
+      },
+      background: {
+        $value: "oklch(0.99 0.005 250)",
+        $type: "color"
+      },
+      foreground: {
+        $value: "oklch(0.15 0.02 250)",
+        $type: "color"
+      }
+    },
+    typography: {
+      heading: {
+        $value: "Inter, system-ui, sans-serif",
+        $type: "fontFamily"
+      },
+      body: {
+        $value: "Inter, system-ui, sans-serif",
+        $type: "fontFamily"
+      }
+    }
+  }
+};
+function resolveBrandYaml(filePath) {
+  let target = resolve2(filePath ?? "brand.yaml");
+  if (existsSync2(target) && statSync(target).isDirectory()) {
+    target = join2(target, "brand.yaml");
+  }
+  return target;
+}
+function cmdInit() {
+  const targetDir = resolve2("brandspec");
+  if (existsSync2(targetDir)) {
+    console.error("brandspec/ already exists. cd brandspec to start working.");
+    process.exit(1);
+  }
+  const templatesDir = getWorkshopTemplatesDir();
+  if (!existsSync2(templatesDir)) {
+    console.error("Templates not found. Ensure brandspec is installed correctly.");
+    process.exit(1);
+  }
+  cpSync(templatesDir, targetDir, { recursive: true });
+  const positionPath = join2(targetDir, "_workshop", "position.yml");
+  if (existsSync2(positionPath)) {
+    let pos = readFileSync2(positionPath, "utf-8");
+    pos = pos.replace('updated: ""', `updated: "${(/* @__PURE__ */ new Date()).toISOString()}"`);
+    writeFileSync2(positionPath, pos, "utf-8");
+  }
+  const clipCmd = process.platform === "darwin" ? "pbcopy" : process.platform === "win32" ? "clip" : "xclip -sel c";
+  console.log("Created brandspec/");
+  console.log();
+  console.log("Next steps:");
+  console.log("  cd brandspec");
+  console.log();
+  console.log("  # Start the brand workshop with any AI:");
+  console.log(`  npx brandspec workshop start | ${clipCmd}`);
+  console.log("  npx brandspec workshop start > prompt.txt  # or save to file");
+  console.log();
+  console.log("  # Or edit brand.yaml directly, then:");
+  console.log("  npx brandspec generate --format tailwind");
+}
+function formatLintReport(report) {
+  const lines = [];
+  const errors = report.results.filter((r) => r.severity === "error");
+  const warnings = report.results.filter((r) => r.severity === "warning");
+  const infos = report.results.filter((r) => r.severity === "info");
+  if (errors.length > 0) {
+    lines.push("");
+    lines.push(red(`Errors (${errors.length}):`));
+    for (const r of errors) {
+      lines.push(red(`  \u2717 [${r.rule}] ${r.message}`));
+    }
+  }
+  if (warnings.length > 0) {
+    lines.push("");
+    lines.push(yellow(`Warnings (${warnings.length}):`));
+    for (const r of warnings) {
+      lines.push(yellow(`  \u26A0 [${r.rule}] ${r.message}`));
+    }
+  }
+  if (infos.length > 0) {
+    lines.push("");
+    lines.push(dim(`Info (${infos.length}):`));
+    for (const r of infos) {
+      lines.push(dim(`  \u2139 [${r.rule}] ${r.message}`));
+    }
+  }
+  return lines.join("\n");
+}
+function cmdLint(args) {
+  const jsonMode = args.includes("--json");
+  const quietMode = args.includes("--quiet");
+  const filePath = args.find((a) => !a.startsWith("-"));
+  const target = resolveBrandYaml(filePath);
+  if (!existsSync2(target)) {
+    if (jsonMode) {
+      console.log(JSON.stringify({ error: `File not found: ${target}` }));
+    } else if (!quietMode) {
+      console.error(`File not found: ${target}`);
+      console.error("Run 'brandspec init' to create one, or specify a path.");
+    }
+    process.exit(1);
+  }
+  const content = readFileSync2(target, "utf-8");
+  const parseResult = parse(content);
+  if (!parseResult.success) {
+    if (jsonMode) {
+      console.log(JSON.stringify({ error: "parse", details: parseResult.errors }));
+    } else if (!quietMode) {
+      console.error(`Parse errors in ${target}:`);
+      for (const err of parseResult.errors) {
+        console.error(`  - ${err}`);
+      }
+    }
+    process.exit(1);
+  }
+  const validationResult = validate(parseResult.data);
+  if (!validationResult.valid) {
+    if (jsonMode) {
+      console.log(JSON.stringify({ error: "schema", details: validationResult.errors }));
+    } else if (!quietMode) {
+      console.error(`Schema validation errors in ${target}:`);
+      for (const err of validationResult.errors) {
+        console.error(`  - ${err}`);
+      }
+    }
+    process.exit(1);
+  }
+  const data = parseResult.data;
+  const report = lintBrandspec(data);
+  if (jsonMode) {
+    console.log(JSON.stringify({
+      name: data.meta.name,
+      score: report.score,
+      errors: report.errors,
+      warnings: report.warnings,
+      infos: report.infos,
+      results: report.results
+    }));
+  } else if (!quietMode) {
+    const scoreText = `${report.score}/100`;
+    const coloredScore = report.score >= 80 ? green(scoreText) : report.score >= 50 ? yellow(scoreText) : red(scoreText);
+    console.log(`${data.meta.name} \u2014 Score: ${coloredScore}`);
+    console.log(formatLintReport(report));
+  }
+  if (report.errors > 0) {
+    process.exit(1);
+  }
+}
+function cmdValidate(args) {
+  if (!args.includes("--json") && !args.includes("--quiet")) {
+    console.error("Hint: 'validate' now runs 'lint'. Use 'brandspec lint' directly.");
+  }
+  cmdLint(args);
+}
+var VALID_FORMATS = ["css", "tailwind", "figma", "sd", "all"];
+function parseFormats(input) {
+  const parts = input.split(",").map((s) => s.trim());
+  for (const p of parts) {
+    if (!VALID_FORMATS.includes(p)) {
+      console.error(`Unknown format: ${p}`);
+      console.error(`Valid formats: ${VALID_FORMATS.join(", ")}`);
+      process.exit(1);
+    }
+  }
+  if (parts.includes("all")) return ["all"];
+  return parts;
+}
+function detectProjectFormat() {
+  const checks = [
+    { file: "tailwind.config.ts", format: "tailwind", hint: "Tailwind project detected" },
+    { file: "tailwind.config.js", format: "tailwind", hint: "Tailwind project detected" },
+    { file: "postcss.config.js", format: "css", hint: "PostCSS project detected" },
+    { file: "postcss.config.mjs", format: "css", hint: "PostCSS project detected" }
+  ];
+  const parentDir = resolve2("..");
+  for (const check of checks) {
+    if (existsSync2(join2(parentDir, check.file))) {
+      return check.format;
+    }
+  }
+  return void 0;
+}
+function cmdGenerate(args) {
+  let filePath;
+  let formatArg;
+  let outDir;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--format" && args[i + 1]) {
+      formatArg = args[++i];
+    } else if (args[i] === "--out" && args[i + 1]) {
+      outDir = args[++i];
+    } else if (!args[i].startsWith("-")) {
+      filePath = args[i];
+    }
+  }
+  let formats;
+  if (formatArg) {
+    formats = parseFormats(formatArg);
+  } else {
+    const detected = detectProjectFormat();
+    if (detected) {
+      console.log(`Detected ${detected} project. Use --format all to generate everything.`);
+      formats = [detected];
+    } else {
+      formats = ["all"];
+    }
+  }
+  const target = resolveBrandYaml(filePath);
+  if (!existsSync2(target)) {
+    console.error(`File not found: ${target}`);
+    console.error("Run 'brandspec init' to create one, or specify a path.");
+    process.exit(1);
+  }
+  const content = readFileSync2(target, "utf-8");
+  const parseResult = parse(content);
+  if (!parseResult.success) {
+    console.error(`Parse errors in ${target}:`);
+    for (const err of parseResult.errors) {
+      console.error(`  - ${err}`);
+    }
+    process.exit(1);
+  }
+  const data = parseResult.data;
+  const out = resolve2(outDir ?? join2(dirname2(target), "output"));
+  mkdirSync2(out, { recursive: true });
+  const generated = [];
+  const shouldGenerate = (f) => formats.includes(f) || formats.includes("all");
+  if (shouldGenerate("css")) {
+    const dest = resolve2(out, "tokens.css");
+    writeFileSync2(dest, toCss(data), "utf-8");
+    generated.push("tokens.css");
+  }
+  if (shouldGenerate("tailwind")) {
+    const dest = resolve2(out, "theme.css");
+    writeFileSync2(dest, toTailwindCss(data), "utf-8");
+    generated.push("theme.css");
+  }
+  if (shouldGenerate("figma")) {
+    const dest = resolve2(out, "figma-tokens.json");
+    writeFileSync2(dest, toFigmaTokens(data), "utf-8");
+    generated.push("figma-tokens.json");
+  }
+  if (shouldGenerate("sd")) {
+    const sdDir = resolve2(out, "style-dictionary");
+    mkdirSync2(sdDir, { recursive: true });
+    const sd = toStyleDictionary(data);
+    writeFileSync2(resolve2(sdDir, "tokens.json"), sd.tokens, "utf-8");
+    writeFileSync2(resolve2(sdDir, "config.json"), sd.config, "utf-8");
+    generated.push("style-dictionary/tokens.json");
+    generated.push("style-dictionary/config.json");
+  }
+  console.log(`Generated from ${data.meta.name}:`);
+  for (const f of generated) {
+    console.log(`  ${out}/${f}`);
+  }
+}
+function getWorkshopTemplatesDir() {
+  return resolve2(__dirname, "..", "workshop", "templates");
+}
+function getWorkshopDir() {
+  return resolve2(__dirname, "..", "workshop");
+}
+function ensureWorkshopState() {
+  const positionPath = resolve2("_workshop", "position.yml");
+  const decisionsPath = resolve2("_workshop", "decisions.yml");
+  if (!existsSync2(positionPath) || !existsSync2(decisionsPath)) {
+    console.error("No _workshop/ state found in current directory.");
+    console.error("Run 'brandspec init' first, then cd into brandspec/.");
+    process.exit(1);
+  }
+  return { positionPath, decisionsPath };
+}
+function isInitialPosition(position) {
+  return /phase:\s*1/.test(position) && /completed_at:\s*null/.test(position);
+}
+function cmdWorkshopStart() {
+  const { positionPath, decisionsPath } = ensureWorkshopState();
+  const position = readFileSync2(positionPath, "utf-8");
+  const decisions = readFileSync2(decisionsPath, "utf-8");
+  const hasDecisions = !/decisions:\s*\[\]/.test(decisions);
+  if (!isInitialPosition(position) || hasDecisions) {
+    console.error("Workshop already in progress \u2014 resuming.");
+    cmdWorkshopResume();
+    return;
+  }
+  const workshopDir = getWorkshopDir();
+  const skillMd = readFileSync2(join2(workshopDir, "SKILL.md"), "utf-8");
+  const flowMd = readFileSync2(join2(workshopDir, "flow.md"), "utf-8");
+  const phase1 = readFileSync2(join2(workshopDir, "phases", "01-discovery.md"), "utf-8");
+  const lines = [];
+  lines.push("# brandspec workshop \u2014 Start Session");
+  lines.push("");
+  lines.push("You are a brand identity facilitator. Guide the user through the brandspec workshop.");
+  lines.push("First ask the user's preferred session language, then proceed with Phase 1: Discovery.");
+  lines.push("");
+  lines.push("---");
+  lines.push("");
+  lines.push(skillMd);
+  lines.push("");
+  lines.push("---");
+  lines.push("");
+  lines.push(flowMd);
+  lines.push("");
+  lines.push("---");
+  lines.push("");
+  lines.push("## Current Phase Guide");
+  lines.push("");
+  lines.push(phase1);
+  lines.push("");
+  lines.push("---");
+  lines.push("");
+  lines.push("Begin the workshop now. Ask the user their preferred session language.");
+  console.log(lines.join("\n"));
+}
+function cmdWorkshopStatus() {
+  const positionPath = resolve2("_workshop", "position.yml");
+  if (!existsSync2(positionPath)) {
+    console.error("No _workshop/position.yml found in current directory.");
+    console.error("Are you inside a brandspec project?");
+    process.exit(1);
+  }
+  const content = readFileSync2(positionPath, "utf-8");
+  console.log("Workshop status:");
+  console.log(content);
+}
+function getPhaseFile(phase) {
+  const phaseFiles = {
+    1: "01-discovery.md",
+    2: "02-concept.md",
+    3: "03-visual.md",
+    4: "04-documentation.md"
+  };
+  const file = phaseFiles[phase];
+  if (!file) return "";
+  const filePath = join2(getWorkshopDir(), "phases", file);
+  return existsSync2(filePath) ? readFileSync2(filePath, "utf-8") : "";
+}
+function cmdWorkshopResume() {
+  const { positionPath, decisionsPath } = ensureWorkshopState();
+  const position = readFileSync2(positionPath, "utf-8");
+  const decisions = readFileSync2(decisionsPath, "utf-8");
+  const phaseMatch = position.match(/phase:\s*(\d+)/);
+  const currentPhase = phaseMatch ? parseInt(phaseMatch[1], 10) : 1;
+  const workshopDir = getWorkshopDir();
+  const skillMd = readFileSync2(join2(workshopDir, "SKILL.md"), "utf-8");
+  const phaseGuide = getPhaseFile(currentPhase);
+  const lines = [];
+  lines.push("# brandspec workshop \u2014 Resume Session");
+  lines.push("");
+  lines.push("You are a brand identity facilitator. The user is resuming a workshop session.");
+  lines.push("Restore context from the state below, then continue where they left off.");
+  lines.push("");
+  lines.push("---");
+  lines.push("");
+  lines.push(skillMd);
+  lines.push("");
+  lines.push("---");
+  lines.push("");
+  lines.push("## Current State");
+  lines.push("");
+  lines.push("### Position");
+  lines.push("```yaml");
+  lines.push(position.trim());
+  lines.push("```");
+  lines.push("");
+  lines.push("### Decisions");
+  lines.push("```yaml");
+  lines.push(decisions.trim());
+  lines.push("```");
+  lines.push("");
+  const memoPath = resolve2("_workshop", "memo.md");
+  if (existsSync2(memoPath)) {
+    const memo = readFileSync2(memoPath, "utf-8").trim();
+    if (memo) {
+      lines.push("### Working Notes");
+      lines.push(memo);
+      lines.push("");
+    }
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push(`## Current Phase Guide (Phase ${currentPhase})`);
+  lines.push("");
+  if (phaseGuide) {
+    lines.push(phaseGuide);
+  }
+  lines.push("");
+  lines.push("---");
+  lines.push("");
+  lines.push("Resume the workshop. Present the restored state summary, then continue from the current step.");
+  console.log(lines.join("\n"));
+}
+function cmdWorkshop(args) {
+  const sub = args[0];
+  if (!sub || sub === "--help") {
+    console.log(`
+brandspec workshop \u2014 AI-facilitated brand creation
+
+Commands:
+  start    Print start prompt for AI (initial state only)
+  resume   Print resume prompt for AI (any state)
+  status   Show current workshop position
+    `.trim());
+    process.exit(0);
+  }
+  switch (sub) {
+    case "start":
+      cmdWorkshopStart();
+      break;
+    case "status":
+      cmdWorkshopStatus();
+      break;
+    case "resume":
+      cmdWorkshopResume();
+      break;
+    default:
+      console.error(`Unknown workshop command: ${sub}`);
+      console.error("");
+      console.error("Available commands:");
+      console.error("  start    Print start prompt for AI (initial state only)");
+      console.error("  resume   Print resume prompt for AI (any state)");
+      console.error("  status   Show current workshop position");
+      process.exit(1);
+  }
+}
+function cmdConsult(args) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
+  const filePath = args.find((a) => !a.startsWith("-"));
+  const target = resolveBrandYaml(filePath);
+  if (!existsSync2(target)) {
+    console.error(`File not found: ${target}`);
+    console.error("Run 'brandspec init' to create one, or specify a path.");
+    process.exit(1);
+  }
+  const content = readFileSync2(target, "utf-8");
+  const parseResult = parse(content);
+  if (!parseResult.success) {
+    console.error(`Parse errors in ${target}:`);
+    for (const err of parseResult.errors) {
+      console.error(`  - ${err}`);
+    }
+    process.exit(1);
+  }
+  const data = parseResult.data;
+  const lines = [];
+  lines.push(`# You are a brand consultant for ${data.meta.name}.`);
+  lines.push("");
+  lines.push("## Your Role");
+  lines.push(
+    "You evaluate business decisions, creative work, and communications against this brand's identity. When asked about any business decision, advertisement, campaign, copy, or design \u2014 assess whether it aligns with the brand. Flag inconsistencies and suggest alternatives."
+  );
+  lines.push("");
+  lines.push("## Brand Identity");
+  lines.push(`- Name: ${data.meta.name}`);
+  if (data.meta.description) lines.push(`- Description: ${data.meta.description}`);
+  if ((_a = data.core) == null ? void 0 : _a.essence) lines.push(`- Essence: ${data.core.essence}`);
+  if ((_b = data.core) == null ? void 0 : _b.tagline) lines.push(`- Tagline: ${data.core.tagline}`);
+  if ((_c = data.core) == null ? void 0 : _c.mission) lines.push(`- Mission: ${data.core.mission}`);
+  if ((_d = data.core) == null ? void 0 : _d.vision) lines.push(`- Vision: ${data.core.vision}`);
+  if ((_f = (_e = data.core) == null ? void 0 : _e.values) == null ? void 0 : _f.length) lines.push(`- Values: ${data.core.values.join(", ")}`);
+  if ((_h = (_g = data.core) == null ? void 0 : _g.personality) == null ? void 0 : _h.length)
+    lines.push(`- Personality: ${data.core.personality.join(", ")}`);
+  lines.push("");
+  if ((_i = data.core) == null ? void 0 : _i.voice) {
+    const v = data.core.voice;
+    lines.push("## Voice & Tone");
+    if ((_j = v.tone) == null ? void 0 : _j.length) lines.push(`Tone: ${v.tone.join(", ")}`);
+    if ((_k = v.principles) == null ? void 0 : _k.length) {
+      lines.push("Principles:");
+      for (const p of v.principles) lines.push(`- ${p}`);
+    }
+    lines.push("");
+  }
+  const hasColors = ((_l = data.tokens) == null ? void 0 : _l.colors) && Object.keys(data.tokens.colors).length > 0;
+  const hasTypography = ((_m = data.tokens) == null ? void 0 : _m.typography) && Object.keys(data.tokens.typography).length > 0;
+  const hasAssets = data.assets && data.assets.length > 0;
+  if (hasColors || hasTypography || hasAssets) {
+    lines.push("## Visual Identity");
+    if (hasColors) {
+      lines.push("Colors:");
+      for (const [name, token] of Object.entries(data.tokens.colors)) {
+        if (token.$description) {
+          const hex = (_o = (_n = token.$extensions) == null ? void 0 : _n.compat) == null ? void 0 : _o.hex;
+          lines.push(`- ${name}: ${token.$description}${hex ? ` (${hex})` : ""}`);
+        }
+      }
+    }
+    if (hasTypography) {
+      lines.push("Typography:");
+      for (const [name, token] of Object.entries(data.tokens.typography)) {
+        const desc = token.$description ? ` \u2014 ${token.$description}` : "";
+        lines.push(`- ${name}: ${token.$value}${desc}`);
+      }
+    }
+    if (hasAssets) {
+      const roles = new Set(data.assets.map((a) => a.role).filter(Boolean));
+      const parts = [];
+      if (roles.has("symbol")) parts.push("symbol");
+      if (roles.has("wordmark")) parts.push("wordmark");
+      if (roles.has("logo")) parts.push("logo");
+      if (roles.has("favicon")) parts.push("favicon");
+      if (parts.length) {
+        lines.push(`Logo system: ${parts.join(" + ")}`);
+      }
+      for (const asset of data.assets) {
+        if (asset.description) {
+          lines.push(`- ${asset.id ?? asset.file}: ${asset.description}`);
+        }
+      }
+    }
+    lines.push("");
+  }
+  if (data.guidelines && Object.keys(data.guidelines).length > 0) {
+    lines.push("## Guidelines");
+    for (const [, section] of Object.entries(data.guidelines)) {
+      if (section.content) {
+        lines.push(section.content.trim());
+        lines.push("");
+      }
+      if ((_p = section.rules) == null ? void 0 : _p.length) {
+        for (const rule of section.rules) {
+          lines.push(`- [${rule.severity}] ${rule.description}`);
+        }
+        lines.push("");
+      }
+    }
+  }
+  if (data.extensions) {
+    const extKeys = Object.keys(data.extensions);
+    if (extKeys.length > 0) {
+      lines.push("## Additional Context");
+      for (const key of extKeys) {
+        const ext = data.extensions[key];
+        if (ext && typeof ext === "object" && !Array.isArray(ext)) {
+          const record = ext;
+          const stringEntries = Object.entries(record).filter(
+            ([, v]) => typeof v === "string"
+          );
+          if (stringEntries.length > 0) {
+            lines.push(`### ${key}`);
+            for (const [k, v] of stringEntries) {
+              lines.push(`- ${k}: ${v}`);
+            }
+            lines.push("");
+          }
+        }
+      }
+    }
+  }
+  lines.push("---");
+  lines.push(
+    "Use this prompt as a system message for any AI model to get brand-aligned consultation."
+  );
+  console.log(lines.join("\n"));
+}
+async function cmdLogin(args) {
+  let token;
+  const tokenIdx = args.indexOf("--token");
+  if (tokenIdx !== -1 && args[tokenIdx + 1]) {
+    token = args[tokenIdx + 1];
+  }
+  if (!token) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    token = await new Promise((resolve3) => {
+      rl.question("API token: ", (answer) => {
+        rl.close();
+        resolve3(answer.trim());
+      });
+    });
+  }
+  if (!token || !token.startsWith("bst_")) {
+    console.error("Invalid token. Token must start with 'bst_'.");
+    process.exit(1);
+  }
+  saveCredentials(token);
+  console.log(`Token saved to ${getCredentialsPath()}`);
+}
+function cmdLogout() {
+  const credPath = getCredentialsPath();
+  if (existsSync2(credPath)) {
+    unlinkSync(credPath);
+    console.log("Logged out. Token removed.");
+  } else {
+    console.log("No saved token found.");
+  }
+}
+function collectFiles(dir, base) {
+  const results = [];
+  if (!existsSync2(dir)) return results;
+  const entries = readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join2(dir, entry.name);
+    const relPath = join2(base, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...collectFiles(fullPath, relPath));
+    } else {
+      results.push({ path: relPath, data: readFileSync2(fullPath) });
+    }
+  }
+  return results;
+}
+async function cmdPull(args) {
+  const token = requireToken();
+  const remote = requireRemote(args);
+  const excludeWorkshop = args.includes("--no-workshop");
+  const url = `${API_BASE}/api/v1/${remote.org}/${remote.brand}/pull${excludeWorkshop ? "" : "?include_workshop=true"}`;
+  const res = await fetch(url, {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  if (!res.ok) {
+    const body = await res.text();
+    console.error(`Pull failed (${res.status}): ${body}`);
+    process.exit(1);
+  }
+  const arrayBuf = await res.arrayBuffer();
+  const JSZip = (await import("jszip")).default;
+  const zip = await JSZip.loadAsync(arrayBuf);
+  const outDir = resolve2("brandspec");
+  mkdirSync2(outDir, { recursive: true });
+  for (const [filePath, zipEntry] of Object.entries(zip.files)) {
+    if (zipEntry.dir) {
+      mkdirSync2(join2(outDir, filePath), { recursive: true });
+    } else {
+      const dest = join2(outDir, filePath);
+      mkdirSync2(dirname2(dest), { recursive: true });
+      const content = await zipEntry.async("nodebuffer");
+      writeFileSync2(dest, content);
+    }
+  }
+  ensureBrandspecrc(remote.org, remote.brand);
+  const fileCount = Object.values(zip.files).filter((f) => !f.dir).length;
+  console.log(`Pulled ${remote.org}/${remote.brand} \u2192 brandspec/ (${fileCount} files)`);
+}
+async function cmdPush(args) {
+  var _a, _b;
+  const token = requireToken();
+  const remote = requireRemote(args);
+  const yamlPath = resolve2("brand.yaml");
+  if (!existsSync2(yamlPath)) {
+    console.error("brand.yaml not found in current directory.");
+    process.exit(1);
+  }
+  const yamlContent = readFileSync2(yamlPath, "utf-8");
+  const formData = new FormData();
+  formData.append("yaml", new Blob([yamlContent], { type: "text/yaml" }), "brand.yaml");
+  const assetsDir = resolve2("assets");
+  const assetFiles = collectFiles(assetsDir, "");
+  for (const file of assetFiles) {
+    formData.append("assets", new Blob([new Uint8Array(file.data)]), file.path);
+  }
+  const workshopDir = resolve2("_workshop");
+  const workshopFiles = collectFiles(workshopDir, "");
+  for (const file of workshopFiles) {
+    formData.append("workshop", new Blob([new Uint8Array(file.data)]), file.path);
+  }
+  const url = `${API_BASE}/api/v1/${remote.org}/${remote.brand}/push`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}` },
+    body: formData
+  });
+  if (!res.ok) {
+    const body = await res.text();
+    console.error(`Push failed (${res.status}): ${body}`);
+    process.exit(1);
+  }
+  const result = await res.json();
+  console.log(`Pushed to ${remote.org}/${remote.brand}: ${result.action ?? "ok"}`);
+  if ((_a = result.warnings) == null ? void 0 : _a.length) {
+    for (const w of result.warnings) {
+      console.warn(`  warn: ${w}`);
+    }
+  }
+  if ((_b = result.assetErrors) == null ? void 0 : _b.length) {
+    for (const e of result.assetErrors) {
+      console.error(`  asset error: ${e}`);
+    }
+  }
+  ensureBrandspecrc(remote.org, remote.brand);
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  if (!command || command === "--help" || command === "-h") {
+    if (!command && existsSync2(resolveBrandYaml())) {
+      cmdLint([]);
+      return;
+    }
+    console.log(HELP);
+    process.exit(0);
+  }
+  if (command === "--version" || command === "-v") {
+    console.log(VERSION);
+    process.exit(0);
+  }
+  switch (command) {
+    case "init":
+      cmdInit();
+      break;
+    case "lint":
+      cmdLint(args.slice(1));
+      break;
+    case "validate":
+      cmdValidate(args.slice(1));
+      break;
+    case "generate":
+      cmdGenerate(args.slice(1));
+      break;
+    case "workshop":
+      cmdWorkshop(args.slice(1));
+      break;
+    case "consult":
+      cmdConsult(args.slice(1));
+      break;
+    case "login":
+      await cmdLogin(args.slice(1));
+      break;
+    case "logout":
+      cmdLogout();
+      break;
+    case "pull":
+      await cmdPull(args.slice(1));
+      break;
+    case "push":
+      await cmdPush(args.slice(1));
+      break;
+    default:
+      console.error(`Unknown command: ${command}`);
+      console.log(HELP);
+      process.exit(1);
+  }
+}
+main();