synthesisui 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SynthesisUI
+
+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,54 @@
+# synthesisui
+
+CLI para trazer design systems publicados no [SynthesisUI](https://www.synthesisui.com)
+para dentro de qualquer projeto. Materializa o sistema em `_local/ds/<slug>/` e injeta
+um bloco gerenciado no `CLAUDE.md` da raiz, de forma que o Claude Code construa
+componentes seguindo o design system.
+
+## Uso
+
+Sem instalar nada:
+
+```bash
+npx synthesisui login        # conecta o CLI à sua conta (device-flow no browser)
+npx synthesisui list         # lista os design systems disponíveis
+npx synthesisui add <slug>   # traz um DS para _local/ds/<slug>/
+```
+
+Ou instale globalmente:
+
+```bash
+npm install -g synthesisui
+synthesisui add halogen
+```
+
+### O que o `add` materializa
+
+Em `_local/ds/<slug>/`:
+
+- `design-system.json` — a verdade canônica do design system
+- `tokens.css` — CSS custom properties escopadas por `data-ds`
+- `GUIDE.md` — instruções para o agente (papéis semânticos, mood, recipes, como adicionar componentes)
+- `.lock` — slug + versão pinada (reproduzível)
+
+E injeta um bloco idempotente `<!-- synthesisui:start/end -->` no `CLAUDE.md` da raiz,
+refletindo todos os DSs instalados.
+
+## Autenticação
+
+`synthesisui login` usa device-flow (RFC 8628): abre o browser, você confirma um código,
+e o token é salvo em `~/.synthesisui/credentials.json` (por máquina). Logout = apagar esse arquivo.
+
+## Registry
+
+Por padrão aponta para `https://www.synthesisui.com`. Sobrescreva com:
+
+```bash
+synthesisui list --registry http://localhost:3000
+# ou
+SYNTHESISUI_REGISTRY_URL=http://localhost:3000 synthesisui list
+```
+
+## Licença
+
+MIT

package/dist/claude-md.js

@@ -0,0 +1,83 @@
+import { readdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+const START = "<!-- synthesisui:start -->";
+const END = "<!-- synthesisui:end -->";
+/** Lê os DSs instalados a partir dos .lock em _local/ds/<slug>/. */
+async function readInstalled(projectRoot) {
+    const dsDir = join(projectRoot, "_local", "ds");
+    let entries = [];
+    try {
+        const dirents = await readdir(dsDir, { withFileTypes: true });
+        entries = dirents.filter((d) => d.isDirectory()).map((d) => d.name);
+    }
+    catch {
+        return [];
+    }
+    const locks = [];
+    for (const slug of entries.sort()) {
+        try {
+            const raw = await readFile(join(dsDir, slug, ".lock"), "utf8");
+            const lock = JSON.parse(raw);
+            locks.push({ slug: lock.slug, name: lock.name, version: lock.version });
+        }
+        catch {
+            // pasta sem .lock válido — ignora
+        }
+    }
+    return locks;
+}
+function renderRegion(installed) {
+    if (installed.length === 0) {
+        return `${START}\n${END}`;
+    }
+    const lines = installed
+        .map((ds) => `- **${ds.name}** (\`${ds.slug}\`, v${ds.version}) — guia: \`_local/ds/${ds.slug}/GUIDE.md\``)
+        .join("\n");
+    const body = `## Design Systems (via SynthesisUI)
+
+Este projeto usa design system(s) trazido(s) pelo \`synthesisui\` CLI. **Ao criar ou editar
+componentes, leia o GUIDE.md do sistema e siga-o:** use apenas tokens semânticos
+(\`var(--ds-color-semantic-*)\`, \`--ds-spacing-*\`, etc.), escope a UI com \`data-ds="<slug>"\`,
+e reaproveite as classes \`.ds-*\`. Não use valores crus fora da escala do sistema.
+
+${lines}
+
+_Bloco gerenciado pelo CLI — não edite à mão; rode \`synthesisui add <slug>\` para atualizar._`;
+    return `${START}\n${body}\n${END}`;
+}
+/**
+ * Regenera o bloco gerenciado no CLAUDE.md da raiz refletindo todos os DSs
+ * instalados. Idempotente: substitui o trecho entre os marcadores se existir,
+ * senão cria o arquivo / anexa o bloco. Retorna se o arquivo foi criado.
+ */
+export async function syncClaudeMd(projectRoot) {
+    const installed = await readInstalled(projectRoot);
+    const region = renderRegion(installed);
+    const path = join(projectRoot, "CLAUDE.md");
+    let existing = null;
+    try {
+        existing = await readFile(path, "utf8");
+    }
+    catch {
+        existing = null;
+    }
+    if (existing === null) {
+        await writeFile(path, `${region}\n`, "utf8");
+        return { created: true, count: installed.length };
+    }
+    const startIdx = existing.indexOf(START);
+    const endIdx = existing.indexOf(END);
+    let next;
+    if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
+        next =
+            existing.slice(0, startIdx) +
+                region +
+                existing.slice(endIdx + END.length);
+    }
+    else {
+        const sep = existing.endsWith("\n") ? "\n" : "\n\n";
+        next = `${existing}${sep}${region}\n`;
+    }
+    await writeFile(path, next, "utf8");
+    return { created: false, count: installed.length };
+}

package/dist/commands/add.js

@@ -0,0 +1,50 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { syncClaudeMd } from "../claude-md.js";
+import { resolveRegistry } from "../config.js";
+import { buildGuide } from "../guide.js";
+import { fetchDesignSystem } from "../registry.js";
+/**
+ * Materializa um DS publicado em `_local/ds/<slug>/` e atualiza o CLAUDE.md.
+ */
+export async function add(slug, opts) {
+    const base = resolveRegistry(opts.registry);
+    const projectRoot = opts.dir ?? process.cwd();
+    console.log(`→ buscando "${slug}" em ${base} …`);
+    const payload = await fetchDesignSystem(base, slug);
+    const targetDir = join(projectRoot, "_local", "ds", payload.slug);
+    await mkdir(targetDir, { recursive: true });
+    // 1. artifacts compilados pelo servidor (tokens.css, e futuros theme.css…)
+    for (const [filename, content] of Object.entries(payload.artifacts)) {
+        await writeFile(join(targetDir, filename), content, "utf8");
+    }
+    // 2. verdade canônica
+    await writeFile(join(targetDir, "design-system.json"), `${JSON.stringify(payload.document, null, 2)}\n`, "utf8");
+    // 3. guia para o agente (gerado client-side a partir do document)
+    await writeFile(join(targetDir, "GUIDE.md"), buildGuide(payload), "utf8");
+    // 4. lock reproduzível
+    const lock = {
+        slug: payload.slug,
+        name: payload.name,
+        version: payload.version,
+        registry: base,
+        fetchedAt: new Date().toISOString(),
+    };
+    await writeFile(join(targetDir, ".lock"), `${JSON.stringify(lock, null, 2)}\n`, "utf8");
+    // 5. descoberta pelo agente
+    const claudeMd = await syncClaudeMd(projectRoot);
+    const files = [
+        ...Object.keys(payload.artifacts),
+        "design-system.json",
+        "GUIDE.md",
+        ".lock",
+    ];
+    console.log(`✓ ${payload.name} v${payload.version} → _local/ds/${payload.slug}/`);
+    console.log(`  ${files.join(", ")}`);
+    console.log(`  CLAUDE.md ${claudeMd.created ? "criado" : "atualizado"} (${claudeMd.count} sistema(s) instalado(s))`);
+    console.log("");
+    console.log("Próximos passos:");
+    console.log(`  • @import "_local/ds/${payload.slug}/tokens.css" no seu CSS global`);
+    console.log(`  • escope sua UI com data-ds="${payload.slug}"`);
+    console.log(`  • detalhes e regras em _local/ds/${payload.slug}/GUIDE.md`);
+}

package/dist/commands/list.js

@@ -0,0 +1,17 @@
+import { resolveRegistry } from "../config.js";
+import { fetchList } from "../registry.js";
+/** Lista os design systems publicados disponíveis no registry. */
+export async function list(opts) {
+    const base = resolveRegistry(opts.registry);
+    const systems = await fetchList(base);
+    if (systems.length === 0) {
+        console.log(`Nenhum design system publicado em ${base}.`);
+        return;
+    }
+    console.log(`Design systems disponíveis (${base}):\n`);
+    const width = Math.max(...systems.map((s) => s.slug.length));
+    for (const s of systems) {
+        console.log(`  ${s.slug.padEnd(width)}  ${s.name}  (v${s.version})`);
+    }
+    console.log(`\nTraga um com:  synthesisui add <slug>`);
+}

package/dist/commands/login.js

@@ -0,0 +1,79 @@
+import { spawn } from "node:child_process";
+import { resolveRegistry, writeToken } from "../config.js";
+import { RegistryError } from "../registry.js";
+const CLIENT_ID = "synthesisui-cli";
+const GRANT_TYPE = "urn:ietf:params:oauth:grant-type:device_code";
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/** Tenta abrir o browser no SO; silencioso se não der. */
+function openBrowser(url) {
+    const [cmd, args] = process.platform === "darwin"
+        ? ["open", [url]]
+        : process.platform === "win32"
+            ? ["cmd", ["/c", "start", "", url]]
+            : ["xdg-open", [url]];
+    try {
+        const child = spawn(cmd, args, {
+            stdio: "ignore",
+            detached: true,
+        });
+        child.on("error", () => { });
+        child.unref();
+    }
+    catch {
+        // sem browser disponível — o usuário abre manualmente
+    }
+}
+/** Device authorization (RFC 8628): abre o browser, espera a aprovação. */
+export async function login(opts) {
+    const base = resolveRegistry(opts.registry);
+    const codeRes = await fetch(`${base}/api/auth/device/code`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ client_id: CLIENT_ID }),
+    }).catch(() => null);
+    if (!codeRes || !codeRes.ok) {
+        throw new RegistryError(`Não consegui iniciar o login em ${base}` +
+            (codeRes
+                ? ` (HTTP ${codeRes.status}).`
+                : ". Confira a URL e a conexão."));
+    }
+    const code = (await codeRes.json());
+    console.log("\nPara conectar o CLI à sua conta:");
+    console.log(`  1. abra: ${code.verification_uri}`);
+    console.log(`  2. confirme o código: ${code.user_code}\n`);
+    console.log("(tentando abrir o navegador…)");
+    openBrowser(code.verification_uri_complete);
+    let interval = (code.interval || 5) * 1000;
+    const deadline = Date.now() + (code.expires_in || 900) * 1000;
+    process.stdout.write("aguardando aprovação");
+    while (Date.now() < deadline) {
+        await sleep(interval);
+        process.stdout.write(".");
+        const tokenRes = await fetch(`${base}/api/auth/device/token`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                grant_type: GRANT_TYPE,
+                device_code: code.device_code,
+                client_id: CLIENT_ID,
+            }),
+        }).catch(() => null);
+        const data = tokenRes
+            ? (await tokenRes.json().catch(() => ({})))
+            : {};
+        if (tokenRes?.ok && typeof data.access_token === "string") {
+            await writeToken(data.access_token, base);
+            console.log("\n✓ Login concluído. Token salvo em ~/.synthesisui/credentials.json");
+            return;
+        }
+        const err = data.error;
+        if (err === "authorization_pending")
+            continue;
+        if (err === "slow_down") {
+            interval += 5000;
+            continue;
+        }
+        throw new RegistryError(`\nLogin falhou: ${data.error_description ?? err ?? tokenRes?.status ?? "erro desconhecido"}`);
+    }
+    throw new RegistryError("\nO código expirou antes da aprovação. Rode `synthesisui login` de novo.");
+}

package/dist/config.js

@@ -0,0 +1,37 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+/**
+ * Registry padrão (domínio canônico de produção). Sobrescrevível por
+ * `--registry <url>` ou `SYNTHESISUI_REGISTRY_URL` (ex.: http://localhost:3000
+ * em dev).
+ */
+export const DEFAULT_REGISTRY = "https://www.synthesisui.com";
+export function resolveRegistry(flag) {
+    const base = flag || process.env.SYNTHESISUI_REGISTRY_URL || DEFAULT_REGISTRY;
+    return base.replace(/\/+$/, ""); // sem barra final
+}
+/** Onde o token do device-flow (passo 3) vive — por máquina, na home. */
+export const credentialsPath = join(homedir(), ".synthesisui", "credentials.json");
+/**
+ * Lê o token salvo, se existir. Hoje opcional (portão aberto); o device-flow
+ * (passo 3) é quem vai gravá-lo. Mandamos como Bearer quando presente.
+ */
+export async function readToken() {
+    try {
+        const raw = await readFile(credentialsPath, "utf8");
+        const parsed = JSON.parse(raw);
+        return parsed.token ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Persiste o token do device-flow (chmod 600, dir só do usuário). */
+export async function writeToken(token, registry) {
+    await mkdir(dirname(credentialsPath), { recursive: true, mode: 0o700 });
+    const payload = { token, registry, savedAt: new Date().toISOString() };
+    await writeFile(credentialsPath, `${JSON.stringify(payload, null, 2)}\n`, {
+        mode: 0o600,
+    });
+}

package/dist/guide.js

@@ -0,0 +1,97 @@
+const kebab = (v) => v.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+const list = (items) => items.length ? items.map((i) => `\`${i}\``).join(", ") : "_(nenhum)_";
+/**
+ * Gera o GUIDE.md — instruções *para o agente* sobre como construir
+ * componentes seguindo o DS. É a peça que faz "com claude-code eu crio os
+ * componentes" funcionar: não basta os tokens, o agente precisa das regras
+ * e do vocabulário real (nomes de tokens semânticos e de recipes).
+ */
+export function buildGuide(payload) {
+    const { document: doc, slug, name, version } = payload;
+    const { meta, foundations, motion, components } = doc;
+    const semanticRoles = Object.keys(foundations.color.semantic);
+    const hasAlt = foundations.color.semanticAlt &&
+        Object.keys(foundations.color.semanticAlt).length > 0;
+    const altScheme = meta.scheme === "light" ? "dark" : "light";
+    const componentLines = Object.entries(components).map(([cname, recipe]) => {
+        const cls = `.ds-${kebab(cname)}`;
+        const axes = Object.entries(recipe.variants).map(([axis, opts]) => {
+            const options = Object.keys(opts);
+            return `\`data-${kebab(axis)}="${options.join("|")}"\``;
+        });
+        const variantsText = axes.length ? ` — variantes: ${axes.join(", ")}` : "";
+        return `- **${cname}** (\`${cls}\`)${variantsText}\n  ${recipe.description}`;
+    });
+    const artifactList = Object.keys(payload.artifacts)
+        .map((f) => `\`${f}\``)
+        .join(", ");
+    return `# Design System: ${name}
+
+> Gerado por \`synthesisui add ${slug}\` (v${version}). **Não edite à mão** —
+> rode \`synthesisui add ${slug}\` de novo para atualizar.
+
+${meta.tagline}
+
+**Mood:** ${meta.mood.join(" · ")}
+**Modo padrão:** ${meta.scheme}${hasAlt ? ` (suporta toggle para ${altScheme})` : ""}
+${meta.sourceUrl ? `**Releitura de:** ${meta.sourceUrl}` : "**Sistema autoral.**"}
+
+${meta.narrative}
+
+---
+
+## Como aplicar
+
+1. Importe os tokens uma vez no CSS global do projeto:
+   \`\`\`css
+   @import "./_local/ds/${slug}/tokens.css";
+   \`\`\`
+   (ajuste o caminho relativo conforme a localização do seu CSS.)
+
+2. Envolva a árvore que deve usar o sistema com o atributo de escopo:
+   \`\`\`html
+   <div data-ds="${slug}">…sua UI aqui…</div>
+   \`\`\`
+   Todas as custom properties \`--ds-*\` e as classes \`.ds-*\` só valem dentro desse escopo.
+${hasAlt
+        ? `
+3. Light/dark: um ancestral com \`data-scheme="${altScheme}"\` troca os papéis neutros para o modo oposto.
+   \`\`\`html
+   <div data-scheme="${altScheme}"><div data-ds="${slug}">…</div></div>
+   \`\`\`
+`
+        : ""}
+Artefatos disponíveis em \`_local/ds/${slug}/\`: ${artifactList}, \`design-system.json\` (verdade canônica), \`GUIDE.md\` (este arquivo).
+
+---
+
+## Regras (siga ao criar componentes)
+
+- **Use SEMPRE tokens semânticos**, nunca valores crus nem primitivas diretas.
+  Cor: \`var(--ds-color-semantic-<papel>)\`. Os papéis são: ${list(semanticRoles)}.
+- Primitivas (\`--ds-color-<paleta>-<step>\`) existem mas **não** devem ser referenciadas direto —
+  elas alimentam os papéis semânticos.
+- Espaçamento → \`var(--ds-spacing-<key>)\`: ${list(Object.keys(foundations.spacing))}.
+- Raio → \`var(--ds-radius-<key>)\`: ${list(Object.keys(foundations.radius))}.
+- Sombra → \`var(--ds-shadow-<key>)\`: ${list(Object.keys(foundations.shadow))}.
+- Tipografia: famílias \`--ds-typography-families-{display,body,mono}\` (${foundations.typography.families.display}, ${foundations.typography.families.body}, ${foundations.typography.families.mono});
+  escala \`--ds-typography-scale-<key>-font-size\` etc.: ${list(Object.keys(foundations.typography.scale))}.
+- Motion: durações \`--ds-motion-durations-<key>\` (${list(Object.keys(motion.durations))}) e
+  easings \`--ds-motion-easings-<key>\` (${list(Object.keys(motion.easings))}).
+- Ao **criar um componente novo** que o DS ainda não cobre: componha a partir desses tokens
+  semânticos para herdar a identidade do sistema; não invente cores/medidas fora da escala.
+
+---
+
+## Componentes prontos
+
+Cada recipe vira uma classe \`.ds-<nome>\` (dentro do escopo \`[data-ds="${slug}"]\`).
+Variantes são atributos \`data-<eixo>="<opção>"\`; estados (hover/focus/active/disabled) já vêm no CSS.
+
+${componentLines.join("\n\n")}
+
+---
+
+_Verdade canônica completa (incluindo valores e keyframes) em \`design-system.json\`._
+`;
+}

package/dist/index.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+import { add } from "./commands/add.js";
+import { list } from "./commands/list.js";
+import { login } from "./commands/login.js";
+import { RegistryError } from "./registry.js";
+const HELP = `synthesisui — traz design systems do SynthesisUI para o seu projeto
+
+Uso:
+  synthesisui login [opções]           conecta o CLI à sua conta (device-flow)
+  synthesisui list [opções]            lista os DSs publicados
+  synthesisui add <slug> [opções]      materializa um DS em _local/ds/<slug>/
+
+Opções:
+  --registry <url>   URL do registry (ou env SYNTHESISUI_REGISTRY_URL)
+  --dir <path>       raiz do projeto consumidor (default: diretório atual)
+  -h, --help         esta ajuda
+
+Exemplos:
+  synthesisui login
+  synthesisui list
+  synthesisui add halogen
+  synthesisui add halogen --registry http://localhost:3737
+`;
+/** Extrai `--flag value` simples e os posicionais restantes. */
+function parseFlags(argv) {
+    const positionals = [];
+    const flags = {};
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "-h" || arg === "--help") {
+            flags.help = true;
+        }
+        else if (arg.startsWith("--")) {
+            const key = arg.slice(2);
+            const next = argv[i + 1];
+            if (next !== undefined && !next.startsWith("--")) {
+                flags[key] = next;
+                i++;
+            }
+            else {
+                flags[key] = true;
+            }
+        }
+        else {
+            positionals.push(arg);
+        }
+    }
+    return { positionals, flags };
+}
+async function main() {
+    const { positionals, flags } = parseFlags(process.argv.slice(2));
+    const [command, ...args] = positionals;
+    if (!command || flags.help || command === "help") {
+        console.log(HELP);
+        return;
+    }
+    const registry = typeof flags.registry === "string" ? flags.registry : undefined;
+    const dir = typeof flags.dir === "string" ? flags.dir : undefined;
+    switch (command) {
+        case "list":
+            await list({ registry });
+            break;
+        case "add": {
+            const slug = args[0];
+            if (!slug) {
+                console.error("erro: informe o slug — `synthesisui add <slug>`");
+                process.exitCode = 1;
+                return;
+            }
+            await add(slug, { registry, dir });
+            break;
+        }
+        case "login":
+            await login({ registry });
+            break;
+        default:
+            console.error(`comando desconhecido: "${command}"\n`);
+            console.log(HELP);
+            process.exitCode = 1;
+    }
+}
+main().catch((err) => {
+    if (err instanceof RegistryError) {
+        console.error(`erro: ${err.message}`);
+    }
+    else {
+        console.error(err);
+    }
+    process.exitCode = 1;
+});

package/dist/registry.js

@@ -0,0 +1,39 @@
+import { readToken } from "./config.js";
+export class RegistryError extends Error {
+}
+async function authHeaders() {
+    const token = await readToken();
+    return token ? { Authorization: `Bearer ${token}` } : {};
+}
+async function request(url) {
+    let res;
+    try {
+        res = await fetch(url, { headers: await authHeaders() });
+    }
+    catch {
+        throw new RegistryError(`Não consegui falar com o registry em ${url}. ` +
+            `Confira a URL (--registry / SYNTHESISUI_REGISTRY_URL) e a conexão.`);
+    }
+    return res;
+}
+/** Lista os design systems publicados disponíveis. */
+export async function fetchList(base) {
+    const res = await request(`${base}/api/registry/ds`);
+    if (!res.ok) {
+        throw new RegistryError(`Registry respondeu ${res.status} ao listar.`);
+    }
+    const body = (await res.json());
+    return body.designSystems ?? [];
+}
+/** Busca um DS publicado já compilado (document + artifacts). */
+export async function fetchDesignSystem(base, slug) {
+    const res = await request(`${base}/api/registry/ds/${encodeURIComponent(slug)}`);
+    if (res.status === 404) {
+        throw new RegistryError(`Nenhum design system publicado com slug "${slug}". ` +
+            `Rode \`synthesisui list\` para ver os disponíveis.`);
+    }
+    if (!res.ok) {
+        throw new RegistryError(`Registry respondeu ${res.status} ao buscar "${slug}".`);
+    }
+    return (await res.json());
+}

package/dist/types.js

@@ -0,0 +1,6 @@
+/**
+ * Espelho mínimo do contrato do registry — o CLI é standalone e NÃO importa
+ * `@synthesisui-hub/ds-contracts` (só consome o JSON do endpoint). Tipamos
+ * apenas o que o CLI lê para gerar o GUIDE.md e o .lock.
+ */
+export {};

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "synthesisui",
+  "version": "0.1.0",
+  "description": "Traz design systems do SynthesisUI para qualquer projeto (materializa em _local/ds/).",
+  "type": "module",
+  "bin": {
+    "synthesisui": "dist/index.js"
+  },
+  "files": ["dist"],
+  "keywords": [
+    "synthesisui",
+    "design-system",
+    "design-tokens",
+    "cli",
+    "claude-code"
+  ],
+  "homepage": "https://www.synthesisui.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SynthesisUI/synthesisui-hub.git",
+    "directory": "packages/cli"
+  },
+  "bugs": {
+    "url": "https://github.com/SynthesisUI/synthesisui-hub/issues"
+  },
+  "author": "SynthesisUI",
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "license": "MIT"
+}