synthesisui 0.16.480 → 0.16.481

package/dist/colour-names.js

@@ -53,22 +53,92 @@ function prefixOf(own) {
     ]);
     return n > own.length / 2 && !generic.has(top) ? `--${top}-` : "--color-";
 }
-export async function planColourNames(root, slug, roleHex) {
+/** O que cada papel pinta - o uso em que a troca vale. A principal vale em qualquer um. */
+const KIND = {
+    primary: "any",
+    canvas: "background",
+    surface: "background",
+    foreground: "text",
+    muted: "text",
+    border: "border",
+};
+const kindOf = (prop) => /^(background|bg)/i.test(prop)
+    ? "background"
+    : /^color$/i.test(prop)
+        ? "text"
+        : /(border|outline)/i.test(prop)
+            ? "border"
+            : "other";
+const SKIP_DIRS = new Set([
+    "node_modules",
+    ".next",
+    "dist",
+    "build",
+    "out",
+    "_synthesisui",
+    ".git",
+    "coverage",
+]);
+/** As cores escritas à mão no código dele, com a propriedade que as pinta - CSS e objetos de estilo. */
+async function usesIn(root, slug) {
+    const { readdir } = await import("node:fs/promises");
+    const { relative } = await import("node:path");
+    const out = [];
+    const walk = async (dir) => {
+        for (const e of await readdir(dir, { withFileTypes: true }).catch(() => [])) {
+            if (e.name.startsWith(".") || SKIP_DIRS.has(e.name))
+                continue;
+            const path = join(dir, e.name);
+            if (e.isDirectory())
+                await walk(path);
+            else if (/\.(css|scss|tsx|jsx)$/i.test(e.name)) {
+                const src = (await readFile(path, "utf8").catch(() => "")).replace(blockMarks.END_RE(slug), "\n");
+                const file = relative(root, path).split("\\").join("/");
+                for (const m of src.matchAll(/([a-zA-Z-]+)\s*:\s*["']?[^;{}\n"']*?(#[0-9a-fA-F]{6})\b/g))
+                    if (!m[1].startsWith("--"))
+                        out.push({
+                            hex: m[2].toLowerCase(),
+                            kind: kindOf(m[1]),
+                            file,
+                        });
+            }
+        }
+    };
+    await walk(root);
+    return out;
+}
+export async function planColourNames(root, slug, roleHex, 
+/** As cores de cada papel ANTES da escolha - a versão instalada antes do `add`. Sem ela, vale a cor nova. */
+before = {}) {
     const v = await readVocabulary(root, slug);
     const prefix = prefixOf([...v.own.keys()]);
+    const uses = await usesIn(root, slug);
+    const low = (x) => (x ?? "").trim().toLowerCase();
+    const taken = new Set();
     const names = SIX_ROLES.filter((r) => roleHex[r]).map((role) => {
-        const name = `${prefix}${WORD[role].word}`;
         const value = roleHex[role];
+        const old = low(before[role] ?? value);
+        /**
+         * O NOME DELE PRIMEIRO - o b1 declara `--accent: #c2410c`, e `--color-primary` com o mesmo valor ao lado seria o
+         * vocabulário dele duplicado pelo nosso. Vale o nome que segura a cor de hoje, ou a nova.
+         */
+        const his = [...v.own].find(([n, val]) => !taken.has(n) && (low(val) === old || low(val) === low(value)))?.[0];
+        const name = his ?? `${prefix}${WORD[role].word}`;
+        taken.add(name);
         const have = v.own.get(name);
+        const kind = KIND[role];
+        const painted = uses.some((u) => u.hex === old && (kind === "any" || u.kind === kind));
         return {
             role,
             name,
             value,
             job: WORD[role].job,
-            exists: have != null && have.toLowerCase() === value.toLowerCase(),
+            exists: have != null && low(have) === low(value),
+            theirs: his != null,
+            was: painted ? old : null,
         };
     });
-    return { file: v.global, prefix, names, css: v.css };
+    return { file: v.global, prefix, names, css: v.css, uses };
 }
 /** Escreve o bloco depois do sim dele - `ask` devolve a resposta; com o não, o arquivo fica como estava. */
 export async function writeColourNames(root, slug, plan, ask) {
@@ -94,11 +164,43 @@ export async function writeColourNames(root, slug, plan, ask) {
     await writeFile(path, `${base}\n${block}\n`, "utf8");
     return { written: true };
 }
-/** O PROMPT PRONTO - o que ele cola no agente. Cada valor à mão vira o nome; nenhuma cor nova, nenhum nome novo. */
+/**
+ * O PROMPT PRONTO - o que ele cola no agente.
+ *
+ * A TROCA É PELA COR DE HOJE, e não pela nova: pela galeria, a cor nova não existe no código dele (medido em 28/09 com
+ * a Onyx no e06-galeria), e o que precisa mudar é o teal que ele escreve à mão. E É PELO USO: o branco do b2 é o fundo
+ * do cartão e o texto do botão ao mesmo tempo, e só o primeiro é a superfície.
+ */
 export function agentPrompt(plan) {
+    const where = {
+        any: "",
+        background: "as a background - ",
+        text: "as text - ",
+        border: "as a border - ",
+        other: "",
+    };
+    const lines = plan.names
+        .filter((n) => n.was)
+        .map((n) => `  ${n.was} -> var(${n.name})   (${where[KIND[n.role]]}${n.job})`);
+    const leave = [];
+    for (const n of plan.names) {
+        if (!n.was || KIND[n.role] === "any")
+            continue;
+        const claimed = new Set(plan.names.filter((m) => m.was === n.was).map((m) => KIND[m.role]));
+        const other = plan.uses.filter((u) => u.hex === n.was && !claimed.has(u.kind) && u.kind !== "other");
+        for (const kind of new Set(other.map((u) => u.kind))) {
+            const files = [
+                ...new Set(other.filter((u) => u.kind === kind).map((u) => u.file)),
+            ];
+            leave.push(`  leave ${n.was} where it is ${kind} (${files.join(", ")}) - that is not the ${WORD[n.role].word}`);
+        }
+    }
     return [
         `Replace the colours written by hand in this project with the names declared in ${plan.file ?? "the global stylesheet"}:`,
-        ...plan.names.map((n) => `  ${n.value} -> var(${n.name})   (${n.job})`),
-        "Change only a value that is exactly one of these. Leave every other colour as it is, and do not add or invent a name or a colour - these six were chosen by the person.",
+        ...(lines.length > 0
+            ? lines
+            : ["  (your code writes none of these by hand - nothing to replace)"]),
+        ...leave,
+        "Change a value only where it is used as the line says. Leave every other colour as it is, and do not add or invent a name or a colour - these six were chosen by the person.",
     ].join("\n");
 }

package/dist/commands/colours.js

@@ -14,15 +14,20 @@ import { add } from "./add.js";
 export async function colours(asked, opts) {
     const root = opts.dir ?? process.cwd();
     const slug = asked ?? (await onlyInstalled(root));
+    const slugDir = join(root, "_synthesisui", "ds", slug);
+    /**
+     * AS CORES DE ANTES, lidas antes do `add` - é o que o código dele pinta hoje. Pela galeria, a cor nova não existe no
+     * código dele, e a troca que o prompt pede é da antiga (etapa 01 de "as cores voltam certas", 28/09).
+     */
+    const before = await installedRoles(slugDir);
     /** A versão publicada pelo "Use these colours" - a instalada aqui ainda é a de antes. */
     await add(slug, { registry: opts.registry, dir: root, setupHints: false });
-    const slugDir = join(root, "_synthesisui", "ds", slug);
     const lock = JSON.parse(await readFile(join(slugDir, ".lock"), "utf8").catch(() => "{}"));
     const tokens = typeof lock.version === "number"
         ? await readFile(join(slugDir, `v${lock.version}`, "tokens.css"), "utf8").catch(() => "")
         : "";
     const roleHex = roleColours(tokens);
-    const plan = await planColourNames(root, slug, roleHex);
+    const plan = await planColourNames(root, slug, roleHex, before);
     console.log("");
     console.log(section("Your six colours, back in your code"));
     if (!plan.file) {
@@ -31,7 +36,7 @@ export async function colours(asked, opts) {
     else {
         console.log(body(`These go into ${plan.file}, under names your code can use:`));
         for (const n of plan.names)
-            console.log(body(`    ${n.name}: ${n.value}   ${n.exists ? "(already there)" : `- ${n.job}`}`));
+            console.log(body(`    ${n.name}: ${n.value}   ${n.exists ? "(already there, your name)" : n.theirs ? `(your name, new value) - ${n.job}` : `- ${n.job}`}`));
     }
     const result = await writeColourNames(root, slug, plan, () => opts.yes
         ? Promise.resolve(true)
@@ -73,6 +78,13 @@ export function roleColours(tokensCss) {
     }
     return out;
 }
+/** As seis cores da versão que está instalada agora - `{}` quando ainda não há nenhuma. */
+async function installedRoles(slugDir) {
+    const lock = JSON.parse(await readFile(join(slugDir, ".lock"), "utf8").catch(() => "{}"));
+    if (typeof lock.version !== "number")
+        return {};
+    return roleColours(await readFile(join(slugDir, `v${lock.version}`, "tokens.css"), "utf8").catch(() => ""));
+}
 async function onlyInstalled(root) {
     const entries = await readdir(join(root, "_synthesisui", "ds"), {
         withFileTypes: true,

package/dist/commands/import.js

@@ -5209,6 +5209,8 @@ export async function runImport(opts) {
     // where the person is standing, and because a number they can check beats an
     // invitation they have to trust.
     const n = payload?.normalize;
+    /** Com uma v2 para aprovar, o link é o lugar da decisão, e ele fica mesmo com a porta das cores. */
+    const approveThere = Boolean(n?.decisions && n.decisions > 0);
     if (n?.decisions && n.decisions > 0) {
         console.log("");
         console.log(section("What a v2 would normalize"));
@@ -5223,11 +5225,15 @@ export async function runImport(opts) {
         console.log("");
         console.log(body("Nothing was changed. You approve it there:"));
     }
-    else if (payload?.url) {
+    else if (payload?.url && !payload?.coloursDoor) {
         console.log("");
         console.log(body("Name it, see it, and govern it:"));
     }
-    if (payload?.url)
+    /**
+     * UM CONVITE SÓ (etapa 04 de "as cores voltam certas", 28/09): com a porta das cores, o próximo passo é escolher as
+     * cores, e o link do tour competia com ele no fim da saída.
+     */
+    if (payload?.url && (approveThere || !payload?.coloursDoor))
         console.log(body(`    ${paint.blue(payload.url)}`));
     console.log("");
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "synthesisui",
-  "version": "0.16.480",
+  "version": "0.16.481",
   "description": "Bring SynthesisUI design systems into any project - tokens, typed components, whole pages and an agent-ready CLAUDE.md manifest.",
   "type": "module",
   "bin": {