@advantacode/brander 0.1.0

package/dist/engine/palette.js

@@ -0,0 +1,46 @@
+import { converter } from "culori";
+const toOklch = converter("oklch");
+export const scaleSteps = [50, 100, 200, 300, 400, 500, 600, 700, 800, 900, 950];
+const lightnessByStep = {
+    50: 0.97,
+    100: 0.93,
+    200: 0.87,
+    300: 0.8,
+    400: 0.72,
+    500: 0.65,
+    600: 0.57,
+    700: 0.49,
+    800: 0.4,
+    900: 0.32,
+    950: 0.24
+};
+export function generatePrimitivePalettes(baseColors) {
+    return Object.fromEntries(Object.entries(baseColors).map(([colorName, colorValue]) => [colorName, generatePrimitiveScale(colorValue)]));
+}
+export function resolvePrimitiveReference(palettes, reference) {
+    const [colorName, rawStep] = reference.split(".");
+    const step = Number(rawStep);
+    return palettes[colorName][step];
+}
+function generatePrimitiveScale(baseColorValue) {
+    const baseColor = toOklch(baseColorValue);
+    if (!baseColor) {
+        throw new Error(`Unable to convert color "${baseColorValue}" to oklch.`);
+    }
+    return Object.fromEntries(scaleSteps.map((step) => [step, formatOklchColor({ l: lightnessByStep[step], c: baseColor.c, h: baseColor.h })]));
+}
+function formatOklchColor(color) {
+    const lightness = roundComponent(color.l, 6) ?? "none";
+    const chroma = roundComponent(color.c, 6) ?? "none";
+    const hue = roundComponent(color.h, 3) ?? "none";
+    const alpha = roundComponent(color.alpha, 3);
+    return alpha !== undefined && alpha < 1
+        ? `oklch(${lightness} ${chroma} ${hue} / ${alpha})`
+        : `oklch(${lightness} ${chroma} ${hue})`;
+}
+function roundComponent(value, precision) {
+    if (value === undefined) {
+        return undefined;
+    }
+    return Number(value.toFixed(precision));
+}

package/dist/engine/semantics.js

@@ -0,0 +1,145 @@
+import { converter } from "culori";
+import { resolvePrimitiveReference } from "./palette.js";
+const toRgb = converter("rgb");
+export const themeNames = ["light", "dark"];
+export const semanticTokenNames = [
+    "background",
+    "surface",
+    "text",
+    "muted",
+    "muted-foreground",
+    "card",
+    "card-foreground",
+    "popover",
+    "popover-foreground",
+    "border",
+    "input",
+    "ring",
+    "primary",
+    "primary-foreground",
+    "secondary",
+    "secondary-foreground",
+    "accent",
+    "accent-foreground",
+    "info",
+    "info-foreground",
+    "success",
+    "success-foreground",
+    "warning",
+    "warning-foreground",
+    "danger",
+    "danger-foreground"
+];
+export function buildThemeReferences(palettes) {
+    const lightPrimary = "primary.600";
+    const darkPrimary = "primary.500";
+    const lightSecondary = "secondary.600";
+    const darkSecondary = "secondary.500";
+    const lightAccent = "accent.600";
+    const darkAccent = "accent.500";
+    const lightInfo = "info.600";
+    const darkInfo = "info.500";
+    const lightSuccess = "success.600";
+    const darkSuccess = "success.500";
+    const lightWarning = "warning.600";
+    const darkWarning = "warning.500";
+    const lightDanger = "danger.600";
+    const darkDanger = "danger.500";
+    return {
+        light: {
+            background: "neutral.50",
+            surface: "neutral.100",
+            text: "neutral.950",
+            muted: "neutral.100",
+            "muted-foreground": "neutral.700",
+            card: "neutral.50",
+            "card-foreground": "neutral.950",
+            popover: "neutral.50",
+            "popover-foreground": "neutral.950",
+            border: "neutral.200",
+            input: "neutral.200",
+            ring: "primary.500",
+            primary: lightPrimary,
+            "primary-foreground": pickForegroundReference(palettes, lightPrimary),
+            secondary: lightSecondary,
+            "secondary-foreground": pickForegroundReference(palettes, lightSecondary),
+            accent: lightAccent,
+            "accent-foreground": pickForegroundReference(palettes, lightAccent),
+            info: lightInfo,
+            "info-foreground": pickForegroundReference(palettes, lightInfo),
+            success: lightSuccess,
+            "success-foreground": pickForegroundReference(palettes, lightSuccess),
+            warning: lightWarning,
+            "warning-foreground": pickForegroundReference(palettes, lightWarning),
+            danger: lightDanger,
+            "danger-foreground": pickForegroundReference(palettes, lightDanger)
+        },
+        dark: {
+            background: "neutral.950",
+            surface: "neutral.900",
+            text: "neutral.50",
+            muted: "neutral.900",
+            "muted-foreground": "neutral.300",
+            card: "neutral.900",
+            "card-foreground": "neutral.50",
+            popover: "neutral.900",
+            "popover-foreground": "neutral.50",
+            border: "neutral.800",
+            input: "neutral.800",
+            ring: "primary.400",
+            primary: darkPrimary,
+            "primary-foreground": pickForegroundReference(palettes, darkPrimary),
+            secondary: darkSecondary,
+            "secondary-foreground": pickForegroundReference(palettes, darkSecondary),
+            accent: darkAccent,
+            "accent-foreground": pickForegroundReference(palettes, darkAccent),
+            info: darkInfo,
+            "info-foreground": pickForegroundReference(palettes, darkInfo),
+            success: darkSuccess,
+            "success-foreground": pickForegroundReference(palettes, darkSuccess),
+            warning: darkWarning,
+            "warning-foreground": pickForegroundReference(palettes, darkWarning),
+            danger: darkDanger,
+            "danger-foreground": pickForegroundReference(palettes, darkDanger)
+        }
+    };
+}
+export function resolveThemeValues(palettes, references) {
+    return Object.fromEntries(themeNames.map((themeName) => [
+        themeName,
+        Object.fromEntries(semanticTokenNames.map((semanticTokenName) => [
+            semanticTokenName,
+            resolvePrimitiveReference(palettes, references[themeName][semanticTokenName])
+        ]))
+    ]));
+}
+function pickForegroundReference(palettes, backgroundReference) {
+    const background = resolvePrimitiveReference(palettes, backgroundReference);
+    const lightForeground = "neutral.50";
+    const darkForeground = "neutral.950";
+    const lightContrast = getContrastRatio(background, resolvePrimitiveReference(palettes, lightForeground));
+    const darkContrast = getContrastRatio(background, resolvePrimitiveReference(palettes, darkForeground));
+    return lightContrast >= darkContrast ? lightForeground : darkForeground;
+}
+function getContrastRatio(leftColor, rightColor) {
+    const left = toRgb(leftColor);
+    const right = toRgb(rightColor);
+    if (!left || !right) {
+        return 1;
+    }
+    const leftLuminance = getRelativeLuminance(left.r, left.g, left.b);
+    const rightLuminance = getRelativeLuminance(right.r, right.g, right.b);
+    const lightest = Math.max(leftLuminance, rightLuminance);
+    const darkest = Math.min(leftLuminance, rightLuminance);
+    return (lightest + 0.05) / (darkest + 0.05);
+}
+function getRelativeLuminance(red, green, blue) {
+    const [r, g, b] = [red, green, blue].map(toLinearValue);
+    return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+function toLinearValue(channel) {
+    if (channel <= 0.04045) {
+        return channel / 12.92;
+    }
+    return ((channel + 0.055) / 1.055) ** 2.4;
+}

package/dist/engine/themes.js

@@ -0,0 +1,25 @@
+import { generatePrimitivePalettes } from "./palette.js";
+import { buildThemeReferences, resolveThemeValues } from "./semantics.js";
+export function createTokenModel(baseColors) {
+    const primitivePalettes = generatePrimitivePalettes(baseColors);
+    const themeReferences = buildThemeReferences(primitivePalettes);
+    const themeValues = resolveThemeValues(primitivePalettes, themeReferences);
+    return {
+        color: {
+            primitive: primitivePalettes,
+            semantic: {
+                light: mapThemeTokens(themeReferences.light, themeValues.light),
+                dark: mapThemeTokens(themeReferences.dark, themeValues.dark)
+            }
+        }
+    };
+}
+function mapThemeTokens(references, values) {
+    return Object.fromEntries(Object.entries(references).map(([tokenName, reference]) => [
+        tokenName,
+        {
+            ref: reference,
+            value: values[tokenName]
+        }
+    ]));
+}

package/dist/generate-tokens.js

@@ -0,0 +1,220 @@
+import fs from "fs";
+import path from "path";
+import { pathToFileURL, fileURLToPath } from "url";
+import { config as loadDotEnv } from "dotenv";
+import { writeCssArtifacts } from "./adapters/css.js";
+import { writeFigmaAdapter } from "./adapters/figma.js";
+import { writeMetadataJson, writeTokenModelJson } from "./adapters/json.js";
+import { writeScssArtifacts } from "./adapters/scss.js";
+import { writeTailwindAdapter } from "./adapters/tailwind.js";
+import { writeTypeScriptArtifacts } from "./adapters/typescript.js";
+import { normalizeVariablePrefix } from "./adapters/variables.js";
+import { baseColorNames, resolveBaseColors } from "./engine/color-parser.js";
+import { createTokenModel } from "./engine/themes.js";
+export const supportedFormats = [
+    "all",
+    "css",
+    "json",
+    "typescript",
+    "scss",
+    "tailwind",
+    "bootstrap",
+    "figma"
+];
+export async function generateTokens(options = {}) {
+    const defaultOutputDir = resolveDefaultOutputDir();
+    const outputDir = options.outputDir ? path.resolve(process.cwd(), options.outputDir) : defaultOutputDir;
+    const theme = options.theme ?? "both";
+    const formats = resolveFormats(options.formats);
+    loadDotEnv({ path: path.resolve(process.cwd(), ".env"), quiet: true });
+    const brandConfig = await loadBrandConfig();
+    const prefix = resolveCssPrefix(options.prefix, brandConfig.css?.prefix, process.env.CSS_PREFIX);
+    const baseColors = resolveBaseColors(brandConfig.colors ?? {});
+    const tokenModel = createTokenModel(baseColors);
+    fs.mkdirSync(outputDir, { recursive: true });
+    if (outputDir === defaultOutputDir) {
+        removeLegacyGeneratedFiles();
+    }
+    removeManagedArtifacts(outputDir);
+    const writtenArtifacts = [];
+    const writtenAdapters = [];
+    const variableOptions = { prefix };
+    if (formats.has("css")) {
+        writtenArtifacts.push(...writeCssArtifacts(outputDir, tokenModel, theme, variableOptions));
+    }
+    if (formats.has("json")) {
+        writtenArtifacts.push(...writeTokenModelJson(outputDir, tokenModel));
+    }
+    if (formats.has("scss") || formats.has("bootstrap")) {
+        writtenArtifacts.push(...writeScssArtifacts(outputDir, tokenModel, {
+            includeTokensScss: formats.has("scss"),
+            includeBootstrapAdapter: formats.has("bootstrap"),
+            variableOptions
+        }));
+    }
+    if (formats.has("tailwind")) {
+        writtenArtifacts.push(...writeTailwindAdapter(outputDir, tokenModel, variableOptions));
+        writtenAdapters.push("tailwind");
+    }
+    if (formats.has("bootstrap")) {
+        writtenAdapters.push("bootstrap");
+    }
+    if (formats.has("figma")) {
+        writtenArtifacts.push(...writeFigmaAdapter(outputDir, tokenModel));
+        writtenAdapters.push("figma");
+    }
+    const plannedArtifacts = [...new Set([...writtenArtifacts, ...(formats.has("typescript") ? ["tokens.ts"] : []), "metadata.json"])];
+    const metadata = createGeneratedMetadata(theme, writtenAdapters, plannedArtifacts, prefix);
+    if (formats.has("typescript")) {
+        writtenArtifacts.push(...writeTypeScriptArtifacts(outputDir, tokenModel, metadata));
+    }
+    writtenArtifacts.push(...writeMetadataJson(outputDir, metadata));
+    console.log(`✔ AdvantaCode tokens generated in ${path.relative(process.cwd(), outputDir) || "."}!`);
+}
+async function loadBrandConfig() {
+    const configPath = findBrandConfigPath();
+    if (!configPath) {
+        return {};
+    }
+    try {
+        const importedConfig = await import(pathToFileURL(configPath).href);
+        return parseBrandConfig(importedConfig.default ?? importedConfig, configPath);
+    }
+    catch (error) {
+        throw new Error(`Failed to load ${path.basename(configPath)}.\n${String(error)}`);
+    }
+}
+function findBrandConfigPath() {
+    const candidateFiles = [
+        "brand.config.ts",
+        "brand.config.mts",
+        "brand.config.cts",
+        "brand.config.js",
+        "brand.config.mjs",
+        "brand.config.cjs"
+    ];
+    for (const candidateFile of candidateFiles) {
+        const candidatePath = path.resolve(process.cwd(), candidateFile);
+        if (fs.existsSync(candidatePath)) {
+            return candidatePath;
+        }
+    }
+    return undefined;
+}
+function parseBrandConfig(rawConfig, configPath) {
+    if (typeof rawConfig !== "object" || rawConfig === null || Array.isArray(rawConfig)) {
+        throw new Error(`Expected ${path.basename(configPath)} to export an object.`);
+    }
+    const config = rawConfig;
+    const parsedConfig = {};
+    if ("name" in config && config.name !== undefined) {
+        if (typeof config.name !== "string") {
+            throw new Error(`Expected "name" in ${path.basename(configPath)} to be a string.`);
+        }
+        parsedConfig.name = config.name;
+    }
+    if ("colors" in config && config.colors !== undefined) {
+        if (typeof config.colors !== "object" || config.colors === null || Array.isArray(config.colors)) {
+            throw new Error(`Expected "colors" in ${path.basename(configPath)} to be an object.`);
+        }
+        const colorEntries = Object.entries(config.colors);
+        const parsedColors = {};
+        for (const [colorName, colorValue] of colorEntries) {
+            if (!baseColorNames.includes(colorName)) {
+                throw new Error(`Unsupported color token "${colorName}" in ${path.basename(configPath)}.`);
+            }
+            if (typeof colorValue !== "string") {
+                throw new Error(`Expected color "${colorName}" in ${path.basename(configPath)} to be a string.`);
+            }
+            parsedColors[colorName] = colorValue;
+        }
+        parsedConfig.colors = parsedColors;
+    }
+    if ("css" in config && config.css !== undefined) {
+        if (typeof config.css !== "object" || config.css === null || Array.isArray(config.css)) {
+            throw new Error(`Expected "css" in ${path.basename(configPath)} to be an object.`);
+        }
+        const cssConfig = config.css;
+        const parsedCssConfig = {};
+        if ("prefix" in cssConfig && cssConfig.prefix !== undefined) {
+            if (typeof cssConfig.prefix !== "string") {
+                throw new Error(`Expected "css.prefix" in ${path.basename(configPath)} to be a string.`);
+            }
+            parsedCssConfig.prefix = cssConfig.prefix;
+        }
+        parsedConfig.css = parsedCssConfig;
+    }
+    return parsedConfig;
+}
+function resolveFormats(formats) {
+    const resolvedFormats = new Set();
+    if (!formats || formats.length === 0 || formats.includes("all")) {
+        resolvedFormats.add("css");
+        resolvedFormats.add("json");
+        resolvedFormats.add("typescript");
+        resolvedFormats.add("scss");
+        resolvedFormats.add("tailwind");
+        resolvedFormats.add("bootstrap");
+        resolvedFormats.add("figma");
+        return resolvedFormats;
+    }
+    for (const format of formats) {
+        if (format === "all") {
+            continue;
+        }
+        resolvedFormats.add(format);
+    }
+    return resolvedFormats;
+}
+function removeLegacyGeneratedFiles() {
+    const legacyFiles = [
+        path.resolve(process.cwd(), "dist", "tokens.css"),
+        path.resolve(process.cwd(), "dist", "tokens.ts"),
+        path.resolve(process.cwd(), "dist", "tokens.scss"),
+        path.resolve(process.cwd(), "dist", "tokens.json"),
+        path.resolve(process.cwd(), "dist", "metadata.json"),
+        path.resolve(process.cwd(), "dist", "tailwind-preset.ts"),
+        path.resolve(process.cwd(), "dist", "generated", "tailwind-preset.ts")
+    ];
+    for (const legacyFile of legacyFiles) {
+        fs.rmSync(legacyFile, { force: true });
+    }
+    removeManagedArtifacts(path.resolve(process.cwd(), "dist", "generated"));
+}
+function resolveDefaultOutputDir() {
+    return path.resolve(process.cwd(), "dist", "brander");
+}
+function removeManagedArtifacts(outputDir) {
+    const managedFiles = [
+        "tokens.css",
+        "tokens.json",
+        "tokens.ts",
+        "tokens.scss",
+        "metadata.json",
+        path.join("themes", "light.css"),
+        path.join("themes", "dark.css"),
+        path.join("adapters", "tailwind.preset.ts"),
+        path.join("adapters", "bootstrap.variables.scss"),
+        path.join("adapters", "figma.tokens.json")
+    ];
+    for (const managedFile of managedFiles) {
+        fs.rmSync(path.join(outputDir, managedFile), { force: true });
+    }
+}
+function createGeneratedMetadata(theme, adapters, artifacts, cssPrefix) {
+    const packageJsonPath = fileURLToPath(new URL("../package.json", import.meta.url));
+    const packageVersion = fs.existsSync(packageJsonPath)
+        ? (JSON.parse(fs.readFileSync(packageJsonPath, "utf8")).version ?? "0.0.0")
+        : "0.0.0";
+    return {
+        version: packageVersion,
+        generated: new Date().toISOString(),
+        themes: theme === "both" ? ["light", "dark"] : [theme],
+        adapters: [...new Set(adapters)].sort(),
+        artifacts: [...new Set(artifacts)].sort(),
+        cssPrefix
+    };
+}
+function resolveCssPrefix(cliPrefix, configPrefix, envPrefix) {
+    return normalizeVariablePrefix(cliPrefix ?? envPrefix ?? configPrefix ?? "");
+}

package/dist/index.js

@@ -0,0 +1,205 @@
+#!/usr/bin/env -S node --import tsx/esm
+import fs from "fs";
+import { fileURLToPath, pathToFileURL } from "url";
+import { generateTokens, supportedFormats } from "./generate-tokens.js";
+import { setupProject } from "./setup.js";
+const packageVersion = loadPackageVersion();
+if (isCliEntryPoint()) {
+    process.exit(await runCli(process.argv.slice(2)));
+}
+export async function runCli(args) {
+    try {
+        if (args.includes("--version") || args.includes("-v")) {
+            console.log(packageVersion);
+            return 0;
+        }
+        const command = resolveCommand(args);
+        const commandArgs = command === "generate" ? args : args.slice(1);
+        if (commandArgs.includes("--help") || commandArgs.includes("-h")) {
+            console.log(getHelpText(command));
+            return 0;
+        }
+        if (command === "generate") {
+            await generateTokens(parseGenerateArgs(commandArgs));
+            return 0;
+        }
+        await setupProject(parseSetupArgs(command, commandArgs));
+        return 0;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Error: ${message}`);
+        return 1;
+    }
+}
+function isCliEntryPoint() {
+    const entryPoint = process.argv[1];
+    return Boolean(entryPoint) && pathToFileURL(entryPoint).href === import.meta.url;
+}
+function loadPackageVersion() {
+    const packageJsonPath = fileURLToPath(new URL("../package.json", import.meta.url));
+    if (!fs.existsSync(packageJsonPath)) {
+        return "0.0.0";
+    }
+    return (JSON.parse(fs.readFileSync(packageJsonPath, "utf8")).version ?? "0.0.0");
+}
+function resolveCommand(args) {
+    const firstArg = args[0];
+    if (!firstArg || firstArg.startsWith("-")) {
+        return "generate";
+    }
+    if (firstArg === "setup" || firstArg === "init") {
+        return firstArg;
+    }
+    throw new Error(`Unknown command "${firstArg}". Use --help to see supported commands.`);
+}
+function parseGenerateArgs(args) {
+    const options = {};
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--out") {
+            options.outputDir = getNextArgValue(arg, args, index);
+            index += 1;
+            continue;
+        }
+        if (arg === "--format") {
+            options.formats = getNextArgValue(arg, args, index)
+                .split(",")
+                .map((value) => normalizeFormat(value.trim()));
+            index += 1;
+            continue;
+        }
+        if (arg === "--theme") {
+            const themeValue = getNextArgValue(arg, args, index);
+            if (!["light", "dark", "both"].includes(themeValue)) {
+                throw new Error('Invalid value for --theme. Use "light", "dark", or "both".');
+            }
+            options.theme = themeValue;
+            index += 1;
+            continue;
+        }
+        if (arg === "--prefix") {
+            options.prefix = getNextArgValue(arg, args, index);
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            throw new Error(`Unknown option "${arg}". Use --help to see supported flags.`);
+        }
+    }
+    return options;
+}
+function parseSetupArgs(command, args) {
+    const generateOptions = parseGenerateArgs(args.filter((arg) => !["--style", "--script-name", "--skip-imports", "--skip-script", "--skip-config", "--skip-generate"].includes(arg)));
+    const options = {
+        command,
+        ...generateOptions
+    };
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--out" || arg === "--format" || arg === "--theme" || arg === "--prefix") {
+            index += 1;
+            continue;
+        }
+        if (arg === "--style") {
+            options.stylePath = getNextArgValue(arg, args, index);
+            index += 1;
+            continue;
+        }
+        if (arg === "--script-name") {
+            options.scriptName = getNextArgValue(arg, args, index);
+            index += 1;
+            continue;
+        }
+        if (arg === "--skip-imports") {
+            options.skipImports = true;
+            continue;
+        }
+        if (arg === "--skip-script") {
+            options.skipScript = true;
+            continue;
+        }
+        if (arg === "--skip-config") {
+            options.skipConfig = true;
+            continue;
+        }
+        if (arg === "--skip-generate") {
+            options.skipGenerate = true;
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            throw new Error(`Unknown option "${arg}". Use --help to see supported flags.`);
+        }
+    }
+    return options;
+}
+function getNextArgValue(flag, args, index) {
+    const nextArg = args[index + 1];
+    if (nextArg === undefined) {
+        throw new Error(`Missing value for ${flag}.`);
+    }
+    return nextArg;
+}
+function normalizeFormat(value) {
+    if (value === "ts") {
+        return "typescript";
+    }
+    if (supportedFormats.includes(value)) {
+        return value;
+    }
+    throw new Error(`Unknown format "${value}". Use --help to see supported formats.`);
+}
+function getHelpText(command) {
+    if (command === "setup" || command === "init") {
+        return `AdvantaCode Brander
+
+Usage:
+  advantacode-brander ${command} [options]
+
+Setup options:
+  --out <dir>             Output directory (default: src/brander)
+  --style <path>          Stylesheet file to patch with token imports
+  --script-name <name>    package.json script to create (default: brand:generate)
+  --skip-imports          Do not patch a stylesheet with token imports
+  --skip-script           Do not add a package.json script
+  --skip-config           Do not create brand.config.ts when missing
+  --skip-generate         Do not run token generation after setup
+
+Generation options:
+  --format <list>         Comma-separated formats: all, css, json, typescript|ts, scss, tailwind, bootstrap, figma
+  --theme <value>         Theme CSS output: light, dark, or both (default: both)
+  --prefix <value>        CSS variable prefix. Use "" or omit for no prefix
+
+Examples:
+  advantacode-brander ${command}
+  advantacode-brander ${command} --out src/brander
+  advantacode-brander ${command} --style src/style.css
+  advantacode-brander ${command} --skip-imports --skip-generate
+`;
+    }
+    return `AdvantaCode Brander
+
+Usage:
+  advantacode-brander [options]
+  advantacode-brander setup [options]
+  advantacode-brander init [options]
+
+Commands:
+  setup                   Configure an existing app to use Brander
+  init                    Initialize a new app for Brander-driven tokens
+
+Options:
+  -h, --help              Show this help output
+  -v, --version           Show the installed package version
+  --out <dir>             Output directory (default: dist/brander)
+  --format <list>         Comma-separated formats: all, css, json, typescript|ts, scss, tailwind, bootstrap, figma
+  --theme <value>         Theme CSS output: light, dark, or both (default: both)
+  --prefix <value>        CSS variable prefix. Use "" or omit for no prefix
+
+Examples:
+  advantacode-brander
+  advantacode-brander --out src/tokens
+  advantacode-brander setup --out src/brander --style src/style.css
+  advantacode-brander init --out resources/brander --skip-imports
+`;
+}