rojao-ds 0.1.0-next.10

package/LICENSE

@@ -0,0 +1,32 @@
+MIT License
+
+Copyright (c) 2026 Rojão Studio
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+Arquivos gerados
+
+Os arquivos que esta ferramenta escreve no seu projeto (o tema CSS e o bloco
+entre os marcadores <!-- rojao-ds:start --> e <!-- rojao-ds:end --> em
+CLAUDE.md, AGENTS.md ou .cursorrules) são de quem usa a ferramenta. Você pode
+usá-los, alterá-los e distribuí-los como quiser, sem obrigação de manter aviso
+de licença ou atribuição. A licença MIT acima vale para o código da ferramenta,
+não para o que ela gera.

package/README.md

@@ -0,0 +1,86 @@
+# rojao-ds
+
+A CLI do [Rojão DS](https://ds.rojao.ai): a sua marca vira o tema do design system e o arquivo de
+regras que a IA (Claude Code, Cursor, outros agentes) lê para construir as telas.
+
+```bash
+npx rojao-ds@next init
+```
+
+Pergunta a cor da marca e escreve, na pasta atual:
+
+- `rds-theme.css` — o tema da marca (claro, escuro e a placa de marca `.ds-plate`);
+- `CLAUDE.md` — ou `.cursorrules` / `AGENTS.md`, o que já existir no projeto.
+
+Depois:
+
+```bash
+pnpm add @rojaostudio/ds@next
+```
+
+```css
+/* CSS raiz do app: o tema vem DEPOIS */
+@import "@rojaostudio/ds/styles/rds.css";
+@import "./rds-theme.css";
+```
+
+## Antes de rodar
+
+- Rode na raiz do projeto, com o trabalho commitado: assim o `git diff` mostra exatamente o que a CLI
+  escreveu, e desfazer é um `git checkout`.
+- A CLI escreve só dois arquivos: o tema (`rds-theme.css`, ou o de `--out`) e o bloco entre os
+  marcadores no arquivo de regras. Nada mais é tocado.
+- Ela não escreve através de link simbólico, nem fora da pasta do projeto (salvo `--allow-outside`,
+  e só para o tema). Se o arquivo de regras tiver um marcador órfão ou mais de um bloco, ela para sem
+  escrever e diz o que corrigir.
+- `--recipe` e `--table` são lidos como entrada de terceiro: campos desconhecidos, `$version`/`$schema`
+  fora do formato e cores fora da lista branca (hex, `rgb()`, `rgba()`, `oklch()`) são recusados.
+  Use arquivos que você mesmo baixou de ds.rojao.ai ou exportou do Figma.
+
+## De onde vem a marca
+
+| Opção | Entrada |
+|---|---|
+| `--color <hex>` | uma cor; o motor deriva o resto |
+| `--recipe <arquivo>` | o `recipe.json` baixado em [ds.rojao.ai](https://ds.rojao.ai) |
+| `--table <arquivo>` | a tabela da marca exportada do Figma [RDS] por `figma/export-brand.js` (vem no `@rojaostudio/ds-core`), formato `rds-brand-table/1` |
+
+Sem nenhuma delas, a cor é perguntada no terminal.
+
+## Opções
+
+| Opção | |
+|---|---|
+| `-n, --name <nome>` | nome da marca (padrão: o do recipe/tabela, senão o do `package.json`) |
+| `--target <alvo>` | `claude`, `cursor` ou `agents` (padrão: o arquivo de regras que já existir, senão `claude`) |
+| `-o, --out <arquivo>` | onde escrever o tema (padrão: `rds-theme.css`) |
+| `-y, --yes` | sobrescreve o tema sem perguntar |
+| `--allow-outside` | deixa escrever o tema fora da pasta do projeto |
+| `-h, --help` | ajuda |
+
+O arquivo de regras nunca é sobrescrito: a CLI escreve só o bloco entre `<!-- rojao-ds:start -->` e
+`<!-- rojao-ds:end -->`. Se o arquivo já existe sem o bloco, ele é acrescentado no fim; se já tem, só
+o bloco é trocado e o resto do arquivo fica como está. Rodar de novo não duplica nada.
+
+O tema (`rds-theme.css`) é sobrescrito, então pede confirmação. Sem terminal (CI, script) e sem
+`--yes`, a CLI recusa e não escreve nada.
+
+## Sem dependência
+
+Node 20+. A única dependência é o motor, [`@rojaostudio/ds-core`](https://www.npmjs.com/package/@rojaostudio/ds-core):
+a CLI é uma casca fina sobre `generateRdsTheme`, `rdsThemeFromTable`, `emitRdsCss` e `emitClaudeMd`.
+Quem prefere script usa o motor direto.
+
+## Licença
+
+MIT — veja [LICENSE](./LICENSE). Os arquivos que a CLI gera no seu projeto (o tema CSS e o bloco entre
+os marcadores no CLAUDE.md, AGENTS.md ou .cursorrules) são seus: não precisam de aviso de licença nem de
+atribuição.
+
+O nome e a marca (Rojão, `rojao-ds`, `@rojaostudio/*`) não estão na licença: veja
+[TRADEMARK.md](https://github.com/rojaostudio/ds/blob/main/TRADEMARK.md).
+
+## Privacidade
+
+Nada é coletado nem enviado. A CLI não tem telemetria e não acessa a rede: lê os arquivos que você
+aponta e escreve na pasta do projeto.

package/dist/cli.js

@@ -0,0 +1,611 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { createInterface } from "readline/promises";
+
+// src/init.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { isAbsolute as isAbsolute2, join, relative as relative2, resolve as resolve2, sep } from "path";
+import { parseArgs } from "util";
+
+// src/prerelease.ts
+import { readFileSync } from "fs";
+function isPrerelease() {
+  try {
+    const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+    return Boolean(pkg.version?.includes("-"));
+  } catch {
+    return false;
+  }
+}
+var onTag = (name) => isPrerelease() ? `${name}@next` : name;
+
+// src/recipe.ts
+var BrandFileError = class extends Error {
+};
+var RECIPE_VERSIONS = ["1"];
+var TABLE_SCHEMA = "rds-brand-table/1";
+var HEX = /^#?([0-9a-f]{3}|[0-9a-f]{6})$/i;
+var PALETTE_REF = /^[a-z][a-z0-9]*-\d{2,3}$/i;
+var PALETTE_NAME = /^[a-z][a-z0-9]*$/i;
+var PALETTE_REFS = /* @__PURE__ */ new Set([
+  "neutral",
+  "zinc",
+  "cream",
+  "coal",
+  "red",
+  "green",
+  "blue",
+  "teal",
+  "amber",
+  "purple",
+  "orange",
+  "cobalt",
+  "brick",
+  "moss",
+  "clay",
+  "flare",
+  "ash",
+  "ember",
+  "navy"
+]);
+var asHex = (v) => /^#[0-9a-f]{6}$/i.test(v) ? v : normalizeHex(v);
+function normalizeHex(v) {
+  const m = v.trim().match(HEX);
+  if (!m) return null;
+  const h = m[1].length === 3 ? [...m[1]].map((c) => c + c).join("") : m[1];
+  return `#${h.toUpperCase()}`;
+}
+var isObject = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+var show = (v) => {
+  const s = (typeof v === "string" ? v : JSON.stringify(v) ?? String(v)).replace(/[\r\n\t]+/g, " ");
+  return JSON.stringify(s.length > 40 ? `${s.slice(0, 40)}\u2026` : s);
+};
+var RECIPE_FIELDS = /* @__PURE__ */ new Set([
+  "$version",
+  "name",
+  "description",
+  "archetype",
+  "scaleMode",
+  "allowLiteral",
+  "surfaceTint",
+  "surfaceGradient",
+  "darkenFill",
+  "brand",
+  "palettes",
+  "type",
+  "surface",
+  "text",
+  "fonts",
+  "display",
+  "radius",
+  "surfacePattern",
+  "card",
+  "hero",
+  "layout",
+  "dark",
+  "extras"
+]);
+var OTHER_TYPES = {
+  archetype: "string",
+  scaleMode: "string",
+  allowLiteral: "boolean",
+  surfaceTint: "number",
+  surfaceGradient: "number",
+  darkenFill: "boolean",
+  type: "object",
+  display: "object",
+  radius: "string|object",
+  surfacePattern: "string",
+  card: "object",
+  hero: "object",
+  layout: "string",
+  dark: "object",
+  extras: "object"
+};
+var BRAND_COLORS = /* @__PURE__ */ new Set([
+  "primary",
+  "hover",
+  "onPrimary",
+  "secondary",
+  "onSecondary",
+  "accent",
+  "accentLight",
+  "onAccent",
+  "borderFocus",
+  "heading",
+  "invert"
+]);
+var BRAND_USED = ["secondary", "accent", "heading", "invert"];
+var typeOk = (v, t) => t.split("|").some((one) => one === "object" ? isObject(v) : typeof v === one);
+function parseRecipe(raw, slug2) {
+  if (!isObject(raw)) throw new BrandFileError("recipe inv\xE1lido: esperava um objeto JSON.");
+  const problems = [];
+  const unknown = Object.keys(raw).filter((k) => !RECIPE_FIELDS.has(k));
+  if (unknown.length) problems.push(`campo desconhecido: ${unknown.map(show).join(", ")}`);
+  if (raw.$version === void 0) problems.push(`falta $version (esperava ${RECIPE_VERSIONS.map((v) => `"${v}"`).join(" ou ")})`);
+  else if (!RECIPE_VERSIONS.includes(raw.$version))
+    problems.push(`$version ${show(raw.$version)} n\xE3o \xE9 suportada (esperava ${RECIPE_VERSIONS.map((v) => `"${v}"`).join(" ou ")})`);
+  if (raw.name !== void 0 && typeof raw.name !== "string") problems.push("name: esperava texto");
+  if (raw.description !== void 0 && (typeof raw.description !== "string" || raw.description.length > 1e3))
+    problems.push("description: esperava texto de at\xE9 1000 caracteres");
+  for (const [field, t] of Object.entries(OTHER_TYPES))
+    if (raw[field] !== void 0 && !typeOk(raw[field], t)) problems.push(`${field}: tipo inv\xE1lido (esperava ${t.replace("|", " ou ")})`);
+  for (const axis of ["surface", "text"])
+    if (raw[axis] !== void 0 && !(typeof raw[axis] === "string" && PALETTE_REFS.has(raw[axis])))
+      problems.push(`${axis}: ${show(raw[axis])} n\xE3o \xE9 uma paleta do Roj\xE3o DS`);
+  let fonts = { body: "inter" };
+  if (raw.fonts !== void 0) {
+    if (!isObject(raw.fonts)) problems.push("fonts: esperava um objeto");
+    else {
+      const bad = Object.entries(raw.fonts).filter(
+        ([k, v]) => !["body", "display", "editorial", "mono", "displayKind"].includes(k) || typeof v !== "string" || !/^[a-z0-9-]{1,40}$/i.test(v)
+      );
+      if (bad.length) problems.push(`fonts: ${bad.map(([k]) => show(k)).join(", ")} inv\xE1lido (nome de fonte: letras, d\xEDgitos e h\xEDfen)`);
+      else fonts = { body: "inter", ...raw.fonts };
+    }
+  }
+  const brand = { primary: "" };
+  if (!isObject(raw.brand)) problems.push("falta brand.primary (a cor da marca).");
+  else {
+    const extra = Object.keys(raw.brand).filter((k) => !BRAND_COLORS.has(k));
+    if (extra.length) problems.push(`brand: campo desconhecido ${extra.map(show).join(", ")}`);
+    const primary = typeof raw.brand.primary === "string" ? normalizeHex(raw.brand.primary) : null;
+    if (!primary) problems.push(`falta brand.primary (a cor da marca) em hex, ex.: #7C3AED${raw.brand.primary ? ` \u2014 veio ${show(raw.brand.primary)}` : ""}.`);
+    else brand.primary = primary;
+    for (const [k, v] of Object.entries(raw.brand)) {
+      if (k === "primary" || v === void 0) continue;
+      const ok = typeof v === "string" && (normalizeHex(v) || PALETTE_REF.test(v));
+      if (!ok) problems.push(`brand.${k}: ${show(v)} n\xE3o \xE9 uma cor (hex ou paleta-passo, ex.: teal-500)`);
+      else if (BRAND_USED.includes(k)) brand[k] = asHex(v) ?? v;
+    }
+  }
+  let palettes;
+  if (raw.palettes !== void 0) {
+    if (!isObject(raw.palettes)) problems.push("palettes: esperava um objeto");
+    else {
+      palettes = {};
+      for (const [name, value] of Object.entries(raw.palettes)) {
+        if (!PALETTE_NAME.test(name)) problems.push(`palettes: nome ${show(name)} inv\xE1lido (letras e d\xEDgitos)`);
+        else if (typeof value === "string") {
+          const hex = asHex(value);
+          if (!hex) problems.push(`palettes.${name}: ${show(value)} n\xE3o \xE9 hex`);
+          else palettes[name] = hex;
+        } else if (isObject(value)) {
+          const bad = Object.entries(value).filter(([step, v]) => !/^(50|[1-9]00|950)$/.test(step) || typeof v !== "string" || !normalizeHex(v));
+          if (bad.length) problems.push(`palettes.${name}: passo ${bad.map(([s]) => show(s)).join(", ")} inv\xE1lido (50\u2013900, valor hex)`);
+          else palettes[name] = Object.fromEntries(Object.entries(value).map(([s, v]) => [s, asHex(v)]));
+        } else problems.push(`palettes.${name}: esperava hex ou escala 50\u2013900`);
+      }
+    }
+  }
+  if (problems.length) throw new BrandFileError(`recipe inv\xE1lido:
+  ${problems.join("\n  ")}`);
+  const own = typeof raw.name === "string" ? slug2(raw.name) : "";
+  return {
+    name: own || "marca",
+    ...typeof raw.description === "string" ? { description: raw.description } : {},
+    brand,
+    ...palettes ? { palettes } : {},
+    surface: raw.surface ?? "zinc",
+    text: raw.text ?? "zinc",
+    fonts
+  };
+}
+var TABLE_FIELDS = /* @__PURE__ */ new Set(["$schema", "name", "primitives", "modes", "vars"]);
+var MODES = ["light", "dark", "brand"];
+var stringMap = (v, field, problems) => {
+  if (!isObject(v)) {
+    problems.push(`${field}: esperava um objeto`);
+    return false;
+  }
+  const bad = Object.entries(v).filter(([, x]) => typeof x !== "string");
+  if (bad.length) problems.push(`${field}: ${bad.slice(0, 5).map(([k]) => show(k)).join(", ")} n\xE3o \xE9 texto`);
+  return bad.length === 0;
+};
+function parseTable(raw) {
+  if (!isObject(raw) || !("modes" in raw) || !("primitives" in raw)) {
+    throw new BrandFileError(
+      `tabela inv\xE1lida: esperava o formato ${TABLE_SCHEMA} (com $schema, modes e primitives), exportado por figma/export-brand.js.`
+    );
+  }
+  const problems = [];
+  if (raw.$schema === void 0) problems.push(`falta $schema (esperava "${TABLE_SCHEMA}")`);
+  else if (raw.$schema !== TABLE_SCHEMA) problems.push(`formato desconhecido: ${show(raw.$schema)} (esperava ${TABLE_SCHEMA})`);
+  const unknown = Object.keys(raw).filter((k) => !TABLE_FIELDS.has(k));
+  if (unknown.length) problems.push(`campo desconhecido: ${unknown.map(show).join(", ")}`);
+  if (raw.name !== void 0 && typeof raw.name !== "string") problems.push("name: esperava texto");
+  stringMap(raw.primitives, "primitives", problems);
+  if (!isObject(raw.modes)) problems.push("modes: esperava um objeto");
+  else {
+    const extra = Object.keys(raw.modes).filter((m) => !MODES.includes(m));
+    if (extra.length) problems.push(`modes: modo desconhecido ${extra.map(show).join(", ")}`);
+    for (const m of MODES) if (raw.modes[m] !== void 0) stringMap(raw.modes[m], `modes.${m}`, problems);
+  }
+  if (raw.vars !== void 0) stringMap(raw.vars, "vars", problems);
+  if (problems.length) throw new BrandFileError(`tabela inv\xE1lida:
+  ${problems.join("\n  ")}`);
+  return raw;
+}
+
+// src/safe-write.ts
+import { closeSync, constants, existsSync, ftruncateSync, lstatSync, mkdirSync, openSync, realpathSync, writeSync } from "fs";
+import { dirname, isAbsolute, relative, resolve } from "path";
+var UnsafePathError = class extends Error {
+};
+function inside(parent, child) {
+  const rel = relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+}
+function nearestExisting(p) {
+  let cur = p;
+  while (!existsSync(cur)) {
+    const up = dirname(cur);
+    if (up === cur) break;
+    cur = up;
+  }
+  return cur;
+}
+var isLink = (p) => {
+  try {
+    return lstatSync(p).isSymbolicLink();
+  } catch {
+    return false;
+  }
+};
+function checkDestination(cwd, abs, label, allowOutside = false) {
+  if (isLink(abs)) throw new UnsafePathError(`${label} \xE9 um link simb\xF3lico. Por seguran\xE7a, a CLI n\xE3o escreve atrav\xE9s de links: apague o link ou aponte outro caminho.`);
+  if (allowOutside) return;
+  const root = realpathSync(cwd);
+  const lexical = resolve(cwd, abs);
+  if (!inside(resolve(cwd), lexical) && !inside(root, lexical))
+    throw new UnsafePathError(`${label} fica fora da pasta do projeto (${cwd}). Use --allow-outside se \xE9 isso mesmo.`);
+  const real = realpathSync(nearestExisting(dirname(abs)));
+  if (!inside(root, real))
+    throw new UnsafePathError(`${label} cai fora da pasta do projeto atrav\xE9s de um link (${real}). Use --allow-outside se \xE9 isso mesmo.`);
+}
+function safeWrite(cwd, abs, content, label, allowOutside = false) {
+  checkDestination(cwd, abs, label, allowOutside);
+  mkdirSync(dirname(abs), { recursive: true });
+  checkDestination(cwd, abs, label, allowOutside);
+  let fd;
+  if (!existsSync(abs) && !isLink(abs)) {
+    fd = openSync(abs, "wx");
+  } else {
+    const noFollow = constants.O_NOFOLLOW;
+    fd = noFollow ? openSync(abs, constants.O_WRONLY | noFollow) : openSync(abs, "r+");
+    ftruncateSync(fd, 0);
+  }
+  try {
+    writeSync(fd, content);
+  } finally {
+    closeSync(fd);
+  }
+}
+
+// src/init.ts
+import {
+  emitClaudeMd,
+  emitRdsCss,
+  generateRdsTheme,
+  rdsThemeFromTable
+} from "@rojaostudio/ds-core/generate";
+var TARGETS = {
+  claude: "CLAUDE.md",
+  agents: "AGENTS.md",
+  cursor: ".cursorrules"
+};
+var DEFAULT_OUT = "rds-theme.css";
+var HELP = `rojao-ds \u2014 o tema da sua marca no Roj\xE3o DS 2.0
+
+Uso:
+  npx rojao-ds init [op\xE7\xF5es]
+
+Gera, na pasta atual:
+  \u2022 o tema da marca (${DEFAULT_OUT}), para importar DEPOIS de @rojaostudio/ds/styles/rds.css;
+  \u2022 o arquivo de regras da IA (CLAUDE.md, .cursorrules ou AGENTS.md). Se ele j\xE1 existe, s\xF3 o
+    bloco entre <!-- rojao-ds:start --> e <!-- rojao-ds:end --> \xE9 escrito; o resto fica.
+
+De onde vem a marca (escolha uma; sem nenhuma, a cor \xE9 perguntada):
+  -c, --color <hex>      a cor da marca, ex.: #7C3AED
+  -r, --recipe <arquivo> o recipe.json baixado em ds.rojao.ai
+  -t, --table <arquivo>  a tabela exportada do Figma (figma/export-brand.js, rds-brand-table/1)
+
+Op\xE7\xF5es:
+  -n, --name <nome>      nome da marca (padr\xE3o: o do recipe/tabela, sen\xE3o o do package.json)
+      --target <alvo>    claude | cursor | agents (padr\xE3o: o arquivo que j\xE1 existir, sen\xE3o claude)
+  -o, --out <arquivo>    onde escrever o tema (padr\xE3o: ${DEFAULT_OUT})
+  -y, --yes              sobrescreve o tema sem perguntar
+      --allow-outside    deixa escrever o tema fora da pasta do projeto
+  -h, --help             mostra esta ajuda
+  -v, --version          mostra a vers\xE3o
+
+Exemplos:
+  npx rojao-ds init --color "#7C3AED"
+  npx rojao-ds init --recipe ./marca.recipe.json --target cursor
+  npx rojao-ds init --table ./brand/marca.rds.json --out src/styles/tema.css --yes
+`;
+var CliError = class extends Error {
+};
+function slug(v) {
+  return v.replace(/^@[^/]+\//, "").normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 32);
+}
+var MAX_INPUT = 1024 * 1024;
+function readJson(cwd, file, what) {
+  const path = resolve2(cwd, file);
+  if (!existsSync2(path)) throw new CliError(`${what} n\xE3o encontrado: ${file}`);
+  try {
+    const text = readFileSync2(path, "utf8");
+    if (text.length > MAX_INPUT) throw new CliError(`${what} grande demais (${file}): at\xE9 1 MB.`);
+    return JSON.parse(text);
+  } catch (e) {
+    if (e instanceof CliError) throw e;
+    throw new CliError(`${what} n\xE3o \xE9 um JSON v\xE1lido (${file}): ${e.message}`);
+  }
+}
+function projectName(cwd) {
+  const pkg = join(cwd, "package.json");
+  if (!existsSync2(pkg)) return null;
+  try {
+    const name = JSON.parse(readFileSync2(pkg, "utf8")).name;
+    return typeof name === "string" && slug(name) ? slug(name) : null;
+  } catch {
+    return null;
+  }
+}
+function fromColor(hex, name) {
+  return { name, brand: { primary: hex }, surface: "zinc", text: "zinc", fonts: { body: "inter" } };
+}
+var BLOCK_START = "<!-- rojao-ds:start -->";
+var BLOCK_END = "<!-- rojao-ds:end -->";
+function rulesBlock(md) {
+  return `${BLOCK_START}
+${md.replace(/\s+$/, "")}
+${BLOCK_END}`;
+}
+var RulesBlockError = class extends Error {
+};
+var count = (text, needle) => text.split(needle).length - 1;
+function mergeRulesBlock(existing, block) {
+  const starts = count(existing, BLOCK_START);
+  const ends = count(existing, BLOCK_END);
+  const start = existing.indexOf(BLOCK_START);
+  const end = existing.indexOf(BLOCK_END);
+  if (starts > 1 || ends > 1)
+    throw new RulesBlockError(`h\xE1 mais de um bloco do Roj\xE3o DS (${starts} in\xEDcio, ${ends} fim). Deixe um s\xF3 par ${BLOCK_START} \u2026 ${BLOCK_END} e rode de novo.`);
+  if (starts !== ends || starts === 1 && end < start)
+    throw new RulesBlockError(`marcador \xF3rf\xE3o: ${starts ? BLOCK_START : BLOCK_END} sem o par na ordem certa. Corrija ou apague os marcadores e rode de novo.`);
+  if (starts === 1) {
+    return { text: existing.slice(0, start) + block + existing.slice(end + BLOCK_END.length), mode: "replaced" };
+  }
+  const head = existing.replace(/\s+$/, "");
+  return { text: head ? `${head}
+
+${block}
+` : `${block}
+`, mode: "appended" };
+}
+async function askColor(io) {
+  for (let i = 0; i < 3; i++) {
+    const hex = normalizeHex(await io.ask("Cor da marca (hex, ex.: #7C3AED): "));
+    if (hex) return hex;
+    io.err("  N\xE3o \xE9 uma cor hex. Use 6 d\xEDgitos, como #7C3AED.");
+  }
+  throw new CliError("cor n\xE3o informada.");
+}
+async function resolveBrand(v, io) {
+  const modes = [v.color, v.recipe, v.table].filter((x) => x !== void 0);
+  if (modes.length > 1) throw new CliError("use s\xF3 uma fonte de marca: --color, --recipe ou --table.");
+  const name = v.name !== void 0 ? slug(v.name) || void 0 : void 0;
+  try {
+    if (v.table !== void 0) {
+      const table = parseTable(readJson(io.cwd, v.table, "tabela"));
+      const n = name ?? (slug(table.name ?? "") || "marca");
+      const theme = rdsThemeFromTable(table);
+      return { label: `tabela do Figma (${v.table})`, name: n, theme, source: { ...table, name: n } };
+    }
+    if (v.recipe !== void 0) {
+      const parsed = parseRecipe(readJson(io.cwd, v.recipe, "recipe"), slug);
+      const def2 = { ...parsed, name: name ?? parsed.name };
+      return { label: `recipe (${v.recipe})`, name: def2.name, theme: generateRdsTheme(def2), source: def2 };
+    }
+    let hex;
+    if (v.color !== void 0) {
+      const h = normalizeHex(v.color);
+      if (!h) throw new CliError(`cor inv\xE1lida: ${v.color} (use hex, ex.: #7C3AED).`);
+      hex = h;
+    } else if (io.interactive) {
+      hex = await askColor(io);
+    } else {
+      throw new CliError("informe a marca: --color <hex>, --recipe <arquivo> ou --table <arquivo>.");
+    }
+    const def = fromColor(hex, name ?? projectName(io.cwd) ?? "marca");
+    return { label: `cor ${hex}`, name: def.name, theme: generateRdsTheme(def), source: def };
+  } catch (e) {
+    if (e instanceof CliError) throw e;
+    if (e instanceof BrandFileError) throw new CliError(e.message);
+    throw new CliError(`n\xE3o foi poss\xEDvel gerar o tema: ${e.message}`);
+  }
+}
+async function resolveTarget(v, io) {
+  if (v.target !== void 0) {
+    const t = v.target.toLowerCase();
+    const byFile = Object.keys(TARGETS).find((k) => TARGETS[k].toLowerCase() === t);
+    if (t in TARGETS) return t;
+    if (byFile) return byFile;
+    throw new CliError(`alvo inv\xE1lido: ${v.target} (use claude, cursor ou agents).`);
+  }
+  const found = Object.keys(TARGETS).filter((k) => existsSync2(join(io.cwd, TARGETS[k])));
+  if (found.length <= 1) return found[0] ?? "claude";
+  if (!io.interactive || v.yes) {
+    io.out(`Encontrei ${found.map((k) => TARGETS[k]).join(", ")}; uso ${TARGETS[found[0]]} (--target escolhe outro).`);
+    return found[0];
+  }
+  const lista = found.map((k, i2) => `${i2 + 1}) ${TARGETS[k]}`).join("  ");
+  const r = (await io.ask(`Encontrei mais de um arquivo de regras: ${lista}. Qual usar? [1] `)).trim();
+  const i = r === "" ? 0 : Number(r) - 1;
+  if (!Number.isInteger(i) || !found[i]) throw new CliError(`op\xE7\xE3o inv\xE1lida: ${r}`);
+  return found[i];
+}
+async function confirm(io, pergunta) {
+  const r = (await io.ask(`${pergunta} (s/N) `)).trim().toLowerCase();
+  return r === "s" || r === "sim" || r === "y" || r === "yes";
+}
+function importPath(cwd, abs) {
+  const rel = relative2(cwd, abs).split(sep).join("/");
+  return rel.startsWith(".") ? rel : `./${rel}`;
+}
+function installCommand(cwd) {
+  const ds = onTag("@rojaostudio/ds");
+  if (existsSync2(join(cwd, "pnpm-lock.yaml"))) return `pnpm add ${ds}`;
+  if (existsSync2(join(cwd, "yarn.lock"))) return `yarn add ${ds}`;
+  if (existsSync2(join(cwd, "bun.lockb")) || existsSync2(join(cwd, "bun.lock"))) return `bun add ${ds}`;
+  if (existsSync2(join(cwd, "package-lock.json"))) return `npm install ${ds}`;
+  return `pnpm add ${ds}`;
+}
+var OPTIONS = {
+  color: { type: "string", short: "c" },
+  recipe: { type: "string", short: "r" },
+  table: { type: "string", short: "t" },
+  name: { type: "string", short: "n" },
+  target: { type: "string" },
+  out: { type: "string", short: "o" },
+  yes: { type: "boolean", short: "y" },
+  "allow-outside": { type: "boolean" },
+  help: { type: "boolean", short: "h" },
+  version: { type: "boolean", short: "v" }
+};
+async function run(argv, io, version2 = "0.0.0") {
+  let values;
+  let positionals;
+  try {
+    ({ values, positionals } = parseArgs({ args: argv, options: OPTIONS, allowPositionals: true, strict: true }));
+  } catch (e) {
+    io.err(`\u2717 ${e.message.replace(/\. To specify.*$/s, "")}`);
+    io.err("  Veja: npx rojao-ds --help");
+    return 1;
+  }
+  if (values.version) {
+    io.out(version2);
+    return 0;
+  }
+  const [command, ...extra] = positionals;
+  if (values.help || command === void 0 || command === "help") {
+    io.out(HELP);
+    return command === void 0 && !values.help ? 1 : 0;
+  }
+  if (command !== "init") {
+    io.err(`\u2717 comando desconhecido: ${command}. O comando \xE9 init.`);
+    io.err("  Veja: npx rojao-ds --help");
+    return 1;
+  }
+  if (extra.length) {
+    io.err(`\u2717 argumento a mais: ${extra.join(" ")}`);
+    return 1;
+  }
+  try {
+    return await init(values, io);
+  } catch (e) {
+    if (e instanceof CliError || e instanceof UnsafePathError || e instanceof RulesBlockError) {
+      io.err(`\u2717 ${e.message}`);
+      if (!(e instanceof CliError)) io.err("  Nada foi escrito.");
+      return 1;
+    }
+    throw e;
+  }
+}
+async function init(v, io) {
+  const brand = await resolveBrand(v, io);
+  const target = await resolveTarget(v, io);
+  const allowOutside = Boolean(v["allow-outside"]);
+  const out = v.out ?? DEFAULT_OUT;
+  if (!out.endsWith(".css")) throw new CliError(`--out precisa terminar em .css: ${out}`);
+  const cssAbs = isAbsolute2(out) ? out : resolve2(io.cwd, out);
+  const rulesAbs = join(io.cwd, TARGETS[target]);
+  const cssImport = importPath(io.cwd, cssAbs);
+  const install = installCommand(io.cwd);
+  let css;
+  let block;
+  try {
+    css = { abs: cssAbs, label: importPath(io.cwd, cssAbs).replace(/^\.\//, ""), content: emitRdsCss(brand.theme) };
+    block = rulesBlock(
+      emitClaudeMd(brand.source, { theme: brand.theme, cssFile: cssImport.replace(/^\.\//, ""), target, install })
+    );
+  } catch (e) {
+    throw new CliError(`n\xE3o foi poss\xEDvel gerar os arquivos: ${e.message}`);
+  }
+  const rules = { abs: rulesAbs, label: TARGETS[target], block };
+  checkDestination(io.cwd, css.abs, css.label, allowOutside);
+  checkDestination(io.cwd, rules.abs, rules.label);
+  const rulesExists = existsSync2(rules.abs);
+  const before = rulesExists ? readFileSync2(rules.abs, "utf8") : "";
+  const merged = rulesExists ? mergeRulesBlock(before, rules.block) : null;
+  const cssExists = existsSync2(css.abs);
+  if (cssExists && !v.yes && !io.interactive) {
+    io.err(`\u2717 ${css.label} j\xE1 existe.`);
+    io.err("  Nada foi escrito. Rode de novo com --yes para sobrescrever.");
+    return 1;
+  }
+  io.out(`Marca: ${brand.name} \u2014 ${brand.label}`);
+  if (cssExists && !v.yes && !await confirm(io, `${css.label} j\xE1 existe. Sobrescrever?`)) {
+    io.out(`\u2013 ${css.label} mantido`);
+  } else {
+    safeWrite(io.cwd, css.abs, css.content, css.label, allowOutside);
+    io.out(`\u2713 ${css.label} ${cssExists ? "atualizado" : "criado"}`);
+  }
+  if (!merged) {
+    safeWrite(io.cwd, rules.abs, `${rules.block}
+`, rules.label);
+    io.out(`\u2713 ${rules.label} criado`);
+  } else if (merged.text === before) io.out(`\u2713 ${rules.label} j\xE1 est\xE1 em dia`);
+  else {
+    safeWrite(io.cwd, rules.abs, merged.text, rules.label);
+    io.out(`\u2713 ${rules.label}: bloco do Roj\xE3o DS ${merged.mode === "replaced" ? "atualizado" : "acrescentado no fim"} (o resto do arquivo foi mantido)`);
+  }
+  io.out("");
+  io.out("Pr\xF3ximos passos:");
+  io.out(`  1. ${install}`);
+  io.out("  2. No CSS raiz do app (o tema vem DEPOIS):");
+  io.out('       @import "@rojaostudio/ds/styles/rds.css";');
+  io.out(`       @import "${cssImport}";`);
+  if (cssImport.slice(2).includes("/") || cssImport.startsWith("../")) {
+    io.out("     (caminho a partir da raiz do projeto: ajuste ao lugar do seu CSS)");
+  }
+  io.out(`  3. Pe\xE7a a tela para a IA: ela l\xEA o ${TARGETS[target]}.`);
+  return 0;
+}
+
+// src/cli.ts
+function version() {
+  try {
+    const pkg = JSON.parse(readFileSync3(new URL("../package.json", import.meta.url), "utf8"));
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+var prompt = {};
+var interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+var code = await run(
+  process.argv.slice(2),
+  {
+    cwd: process.cwd(),
+    out: (l) => process.stdout.write(`${l}
+`),
+    err: (l) => process.stderr.write(`${l}
+`),
+    ask: (q) => {
+      prompt.rl ??= createInterface({ input: process.stdin, output: process.stdout });
+      return prompt.rl.question(q);
+    },
+    interactive
+  },
+  version()
+).catch((e) => {
+  process.stderr.write(`\u2717 erro inesperado: ${e instanceof Error ? e.message : String(e)}
+`);
+  return 1;
+});
+prompt.rl?.close();
+process.exitCode = code;

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "rojao-ds",
+  "version": "0.1.0-next.10",
+  "description": "CLI do Rojão DS — `npx rojao-ds init` gera o tema da sua marca e o arquivo de regras para a IA (CLAUDE.md, .cursorrules, AGENTS.md).",
+  "license": "MIT",
+  "author": "Rojão Studio (https://rojao.studio)",
+  "homepage": "https://ds.rojao.ai",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rojaostudio/ds.git",
+    "directory": "packages/cli"
+  },
+  "bugs": {
+    "url": "https://github.com/rojaostudio/ds/issues"
+  },
+  "keywords": [
+    "design-system",
+    "theme-generator",
+    "cli",
+    "claude",
+    "cursor",
+    "agents",
+    "css-variables"
+  ],
+  "type": "module",
+  "bin": {
+    "rojao-ds": "./dist/cli.js"
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@rojaostudio/ds-core": "1.1.0-next.11"
+  },
+  "devDependencies": {
+    "@types/node": "^20.19.43",
+    "eslint": "^9.18.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5",
+    "vitest": "^4.1.7",
+    "@rojao/config": "0.0.0"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint ."
+  }
+}