rojao-ds 0.1.0-next.6

package/LICENSE

@@ -0,0 +1,21 @@
+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.

package/README.md

@@ -0,0 +1,73 @@
+# 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";
+```
+
+## 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 |
+| `-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.
+
+## Migrar um projeto 0.x/1.x para a 2.0
+
+```bash
+npx rojao-ds@next migrate ./meu-app       # dry-run
+npx rojao-ds@next migrate ./meu-app --apply  # escreve
+```
+
+É um atalho para `npx @rojaostudio/ds-codemod@next` (sem o `@next` depois da 2.0.0), com os mesmos argumentos: o codemod é baixado na
+hora pelo npx, e por isso o `ts-morph` (que traz o compilador do TypeScript) não entra na CLI.
+
+## 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). O nome e a marca não: veja
+[TRADEMARK.md](https://github.com/rojaostudio/ds/blob/main/TRADEMARK.md).

package/dist/cli.js

@@ -0,0 +1,402 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { spawn } from "child_process";
+import { readFileSync as readFileSync3 } from "fs";
+import { createInterface } from "readline/promises";
+
+// src/init.ts
+import { existsSync, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { dirname, isAbsolute, join, relative, resolve, 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/migrate.ts
+var CODEMOD_PACKAGE = onTag("@rojaostudio/ds-codemod");
+var MIGRATE_HELP = `rojao-ds migrate \u2014 leva um projeto do @rojaostudio/ds 0.x/1.x para a 2.0
+
+Uso:
+  npx rojao-ds migrate <pasta-do-projeto> [--apply] [--verbose] [--report <arquivo.json>]
+
+\xC9 um atalho para:
+  npx ${CODEMOD_PACKAGE} <pasta-do-projeto> [...]
+
+Sem --apply \xE9 um dry-run: mostra o plano e os casos manuais (arquivo:linha) e n\xE3o escreve nada.
+`;
+function codemodCommand(args) {
+  return { command: "npx", args: ["--yes", CODEMOD_PACKAGE, ...args] };
+}
+async function runMigrate(args, io) {
+  if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
+    io.out(MIGRATE_HELP);
+    return args.length === 0 ? 1 : 0;
+  }
+  if (!io.spawn) {
+    io.err("\u2717 este ambiente n\xE3o consegue rodar o npx.");
+    return 1;
+  }
+  const { command, args: forwarded } = codemodCommand(args);
+  io.err(`\u2192 ${command} ${forwarded.join(" ")}`);
+  return io.spawn(command, forwarded);
+}
+
+// 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]
+  npx rojao-ds migrate <pasta> [--apply]   migra um projeto 0.x/1.x para a 2.0 (via npx @rojaostudio/ds-codemod)
+
+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
+  -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 {
+};
+var HEX = /^#?([0-9a-f]{3}|[0-9a-f]{6})$/i;
+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()}`;
+}
+function slug(v) {
+  return v.replace(/^@[^/]+\//, "").normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 32);
+}
+function readJson(cwd, file, what) {
+  const path = resolve(cwd, file);
+  if (!existsSync(path)) throw new CliError(`${what} n\xE3o encontrado: ${file}`);
+  try {
+    return JSON.parse(readFileSync2(path, "utf8"));
+  } catch (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 (!existsSync(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" } };
+}
+function fromRecipe(raw, name) {
+  if (!raw || typeof raw !== "object") throw new CliError("recipe inv\xE1lido: esperava um objeto JSON.");
+  const { $version: _v, ...rest } = raw;
+  const brand = rest.brand;
+  if (!brand || typeof brand.primary !== "string" || !brand.primary) {
+    throw new CliError("recipe inv\xE1lido: falta brand.primary (a cor da marca).");
+  }
+  const primary = normalizeHex(brand.primary) ?? brand.primary;
+  const own = typeof rest.name === "string" ? slug(rest.name) : "";
+  return {
+    surface: "zinc",
+    text: "zinc",
+    fonts: { body: "inter" },
+    ...rest,
+    name: name ?? (own || "marca"),
+    brand: { ...brand, primary }
+  };
+}
+function asTable(raw) {
+  const t = raw;
+  if (!t || typeof t !== "object" || !t.modes || !t.primitives) {
+    throw new CliError("tabela inv\xE1lida: esperava o formato rds-brand-table/1 (com modes e primitives), exportado por figma/export-brand.js.");
+  }
+  if (t.$schema && t.$schema !== "rds-brand-table/1") {
+    throw new CliError(`tabela em formato desconhecido: ${t.$schema} (esperava rds-brand-table/1).`);
+  }
+  return t;
+}
+var BLOCK_START = "<!-- rojao-ds:start -->";
+var BLOCK_END = "<!-- rojao-ds:end -->";
+function rulesBlock(md) {
+  return `${BLOCK_START}
+${md.replace(/\s+$/, "")}
+${BLOCK_END}`;
+}
+function mergeRulesBlock(existing, block) {
+  const start = existing.indexOf(BLOCK_START);
+  const end = start === -1 ? -1 : existing.indexOf(BLOCK_END, start);
+  if (start !== -1 && end !== -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 = asTable(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 def2 = fromRecipe(readJson(io.cwd, v.recipe, "recipe"), 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;
+    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) => existsSync(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 = relative(cwd, abs).split(sep).join("/");
+  return rel.startsWith(".") ? rel : `./${rel}`;
+}
+function installCommand(cwd) {
+  const ds = onTag("@rojaostudio/ds");
+  if (existsSync(join(cwd, "pnpm-lock.yaml"))) return `pnpm add ${ds}`;
+  if (existsSync(join(cwd, "yarn.lock"))) return `yarn add ${ds}`;
+  if (existsSync(join(cwd, "bun.lockb")) || existsSync(join(cwd, "bun.lock"))) return `bun add ${ds}`;
+  if (existsSync(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" },
+  help: { type: "boolean", short: "h" },
+  version: { type: "boolean", short: "v" }
+};
+async function run(argv, io, version2 = "0.0.0") {
+  if (argv[0] === "migrate") return runMigrate(argv.slice(1), io);
+  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}. Os comandos s\xE3o init e migrate.`);
+    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) {
+      io.err(`\u2717 ${e.message}`);
+      return 1;
+    }
+    throw e;
+  }
+}
+async function init(v, io) {
+  const brand = await resolveBrand(v, io);
+  const target = await resolveTarget(v, io);
+  const out = v.out ?? DEFAULT_OUT;
+  if (!out.endsWith(".css")) throw new CliError(`--out precisa terminar em .css: ${out}`);
+  const cssAbs = isAbsolute(out) ? out : resolve(io.cwd, out);
+  const rulesAbs = join(io.cwd, TARGETS[target]);
+  const cssImport = importPath(io.cwd, cssAbs);
+  const css = { abs: cssAbs, label: importPath(io.cwd, cssAbs).replace(/^\.\//, ""), content: emitRdsCss(brand.theme) };
+  const rules = {
+    abs: rulesAbs,
+    label: TARGETS[target],
+    block: rulesBlock(emitClaudeMd(brand.source, { theme: brand.theme, cssFile: cssImport.replace(/^\.\//, ""), target }))
+  };
+  const cssExists = existsSync(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 {
+    mkdirSync(dirname(css.abs), { recursive: true });
+    writeFileSync(css.abs, css.content);
+    io.out(`\u2713 ${css.label} ${cssExists ? "atualizado" : "criado"}`);
+  }
+  if (!existsSync(rules.abs)) {
+    writeFileSync(rules.abs, `${rules.block}
+`);
+    io.out(`\u2713 ${rules.label} criado`);
+  } else {
+    const before = readFileSync2(rules.abs, "utf8");
+    const { text, mode } = mergeRulesBlock(before, rules.block);
+    if (text === before) io.out(`\u2713 ${rules.label} j\xE1 est\xE1 em dia`);
+    else {
+      writeFileSync(rules.abs, text);
+      io.out(`\u2713 ${rules.label}: bloco do Roj\xE3o DS ${mode === "replaced" ? "atualizado" : "acrescentado no fim"} (o resto do arquivo foi mantido)`);
+    }
+  }
+  io.out("");
+  io.out("Pr\xF3ximos passos:");
+  io.out(`  1. ${installCommand(io.cwd)}`);
+  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,
+    // npx é um .cmd no Windows, e o Node 20+ só roda .cmd com shell. Os argumentos vêm do próprio usuário.
+    spawn: (command, args) => new Promise((done) => {
+      const win = process.platform === "win32";
+      const argv = win ? args.map((a) => /[\s"]/.test(a) ? `"${a.replace(/"/g, '\\"')}"` : a) : args;
+      const child = spawn(command, argv, { stdio: "inherit", shell: win });
+      child.on("error", (e) => {
+        process.stderr.write(`\u2717 n\xE3o consegui rodar ${command}: ${e.message}
+`);
+        done(1);
+      });
+      child.on("exit", (code2) => done(code2 ?? 1));
+    })
+  },
+  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.6",
+  "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.8"
+  },
+  "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": false
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint ."
+  }
+}