synthesisui 0.16.260 → 0.16.263

package/dist/anatomy-from-sketch.js

@@ -180,6 +180,33 @@ function nameOfTag(tag) {
         .replace(/[^a-z0-9]+/g, "-")
         .replace(/^-|-$/g, "");
 }
+/**
+ * O NOME QUE ELE MESMO DEU AO ELEMENTO - a classe do CSS Module.
+ *
+ * `className={styles.senderConfigContent}` é o cliente nomeando aquele nó. Antes
+ * disto o nó virava `box`, que é o nosso nome para "caixa que carrega decisões e
+ * cujo papel não se lê da tag" - correto e mudo. Medido no monorepo do dono em
+ * 20/08: **1185 dos 5319 nós de sketch carregam `moduleClass`**, em 381 nomes
+ * distintos - `content`, `formControl`, `senderConfig`, `title`, `actions`, `list`.
+ * Todos eles chegavam como `box`.
+ *
+ * É a lei 12 no nível do nó: o que ele declarou vence o que a gente deduziria. E é
+ * a promessa de paridade SEMÂNTICA - devolver o componente com os nomes dele, não
+ * com os nossos.
+ *
+ * A PRIMEIRA palavra, e não a mais longa nem a mais rara: `styles.card styles.open`
+ * é o elemento (`card`) mais um estado (`open`), nessa ordem, porque é assim que
+ * uma pessoa escreve. Escolher outra seria adivinhar qual das duas é o papel.
+ */
+function nameOfModule(moduleClass) {
+    const first = String(moduleClass ?? "")
+        .trim()
+        .split(/\s+/)[0];
+    if (!first)
+        return undefined;
+    const name = nameOfTag(first);
+    return name || undefined;
+}
 /**
  * A HEADLESS PRIMITIVE'S OWN MEMBER NAME, when it says what the thing is.
  *
@@ -517,7 +544,12 @@ versionOf) {
          * chegava com 2 das 35 (04/08).
          */
         if (!name && (classes || node.moduleClass))
-            name = "box";
+            /**
+             * `box` VIROU A ÚLTIMA OPÇÃO, não a primeira - ver `nameOfModule`. Um nó com
+             * classe de module tem nome, e o nome é dele.
+             */
+            name =
+                nameOfModule(node.moduleClass) ?? "box";
         /**
          * A NODE WHOSE CONTENT IS THE CALLER'S is a slot, and it keeps its own name
          * and classes - the border and the hover on a `<tr>{children}</tr>` are real

package/dist/commands/import.js

@@ -4,7 +4,7 @@ import { anatomyFromSketch } from "../anatomy-from-sketch.js";
 import { resolveAnatomy, resolveFlatParts, safePartName, } from "../anatomy-read.js";
 import { readCredentials, readToken, resolveRegistry, sameRegistry, } from "../config.js";
 import { declaredElsewhere } from "../declared-elsewhere.js";
-import { architectureRule, describeArchitecture, describeChoice, detectArchitectures, } from "../doctor/architecture.js";
+import { architectureRule, componentHome, describeArchitecture, describeChoice, detectArchitectures, homeLine, proposeNewHome, } from "../doctor/architecture.js";
 import { findBrokenRefs } from "../doctor/broken-refs.js";
 import { nestingRules, propRules, readDefinitionProps, readNesting, readRuntime, } from "../doctor/call-sites.js";
 import { asCatalogueTable, describeFallback, fetchCatalogue, } from "../doctor/catalogue-fetch.js";
@@ -13,7 +13,7 @@ import { isNearDuplicate, isNeutral, lightness, } from "../doctor/color-distance
 import { describeGate, gateComponent, groupSkips, SCREENS_FOR_SYSTEM, } from "../doctor/component-gate.js";
 import { emptyTally, internalSpecifiers, scanComponentsInto, tallyToInventory, } from "../doctor/components-scan.js";
 import { countShape, describeCoverage, summarizeCoverage, } from "../doctor/coverage.js";
-import { crosswalk, floorSize, isLibrary, observedRules, useLiveCatalogue, } from "../doctor/crosswalk.js";
+import { classifyAside, crosswalk, floorSize, isLibrary, observedRules, useLiveCatalogue, } from "../doctor/crosswalk.js";
 import { keyframeOffsets, moduleImports, partialCandidates, readGlobalClasses, readModuleCss, readModuleUsage, sheetImports, transcribeModule, } from "../doctor/css-modules.js";
 import { dataContract } from "../doctor/data-contract.js";
 import { reconcile, scanDefinitions, } from "../doctor/definitions-scan.js";
@@ -37,6 +37,7 @@ import { frontierKind, packageRoot } from "../frontier-kind.js";
 import { withLibraryStructure } from "../library-structure.js";
 import { mergeCensus } from "../merge-census.js";
 import { claimName } from "../name-claim.js";
+import { namingQueue } from "../naming-queue.js";
 import { body, paint, section } from "../output.js";
 import { phase, startProgress } from "../progress.js";
 import { detectStack, resolveDeps, stackVersions } from "../stack.js";
@@ -703,6 +704,10 @@ export async function takeCensus(root, opts) {
                     if (esize > 0 || etag || esketch.length > 0) {
                         looks[extra.name] = {
                             ...(esketch.length > 0 ? { sketch: esketch } : {}),
+                            /** Ver `CensusLook.aside` - o segundo componente do arquivo também. */
+                            ...(classifyAside(extra.name)
+                                ? { aside: classifyAside(extra.name) }
+                                : {}),
                             ...et,
                             ...(etag ? { rootTag: etag } : {}),
                             ...rootPackage(etag, esketch),
@@ -992,6 +997,10 @@ export async function takeCensus(root, opts) {
                 if (size > 0 || tag) {
                     looks[found[0].name] = {
                         ...(sketch.length > 0 ? { sketch } : {}),
+                        /** Ver `CensusLook.aside`: o fato viaja, a regra fica de um lado só. */
+                        ...(classifyAside(found[0].name)
+                            ? { aside: classifyAside(found[0].name) }
+                            : {}),
                         ...withoutDark,
                         base,
                         states,
@@ -1920,6 +1929,18 @@ export async function takeCensus(root, opts) {
     const brokenRefs = findBrokenRefs(sources, declaredNames);
     const conventions = detectConventions(sources);
     const classStyle = detectClassStyle(sources);
+    /**
+     * A FILA DE NOMES, computada com os MESMOS insumos que o envio usa - ver `namingQueue`.
+     *
+     * O crosswalk e o manifesto entram porque é o que distingue um componente DELES de uma peça de
+     * terceiro, e os dois casos são nós já nomeados. Sem eles a fila cobraria trabalho que não
+     * existe, que é exatamente o defeito que ela vem medir.
+     */
+    const naming = namingQueue(looks, (name) => {
+        const c = components.find((x) => x.name === name && !x.from);
+        const target = c?.canonical ?? (c?.bucket === "exclusive" ? c.name : null);
+        return target ? safePartName(target) : null;
+    }, (pkg) => versions[pkg]);
     return {
         census: 1,
         project: {
@@ -1956,6 +1977,7 @@ export async function takeCensus(root, opts) {
         ...(conventions.length > 0 ? { conventions } : {}),
         classStyle,
         ...(Object.keys(looks).length > 0 ? { looks } : {}),
+        ...(naming.components > 0 ? { naming } : {}),
         ...(schemes.alt.size > 0
             ? { declaredAlt: Object.fromEntries(schemes.alt) }
             : {}),
@@ -2018,8 +2040,16 @@ export async function takeCensus(root, opts) {
             ? {
                 architectures: architectures.slice(0, 6).map((a) => ({
                     ...a,
-                    rule: architectureRule(a),
+                    /** O caminho e a frase que a PERGUNTA usa verbatim - ver `componentHome`. */
+                    home: componentHome(a, scopeLabel),
+                    line: homeLine(a),
+                    rule: architectureRule(a, scopeLabel),
                 })),
+                ...(proposeNewHome(architectures, scopeLabel)
+                    ? {
+                        newComponentHome: proposeNewHome(architectures, scopeLabel),
+                    }
+                    : {}),
             }
             : {}),
         ...(skips.length > 0
@@ -3562,7 +3592,11 @@ export async function runImport(opts) {
             "content-type": "application/json",
             Authorization: `Bearer ${token}`,
         },
-        body: JSON.stringify({ census, name: chosen }),
+        body: JSON.stringify({
+            census,
+            name: chosen,
+            ...(opts.group ? { group: opts.group } : {}),
+        }),
     }).catch(() => null);
     if (!res || !res.ok) {
         const detail = res
@@ -3594,6 +3628,15 @@ export async function runImport(opts) {
     console.log("");
     console.log(section("Your system exists"));
     console.log(body(`${paint.strong(payload?.name ?? "Your system")} - v1 mirrors your tokens exactly, nothing improved yet.`));
+    /**
+     * ONDE ELE NASCEU, dito pela plataforma e não pelo que foi pedido.
+     *
+     * A flag carrega um nome falado e o casamento acontece do outro lado, então imprimir o que foi
+     * pedido provaria nada. Este é o campo que o dono não teve em 20/08, quando dois sistemas
+     * nasceram no espaço pessoal dele e o grupo ficou vazio.
+     */
+    if (payload?.group)
+        console.log(body(paint.dim(`In the group ${payload.group}.`)));
     for (const note of payload?.notes ?? [])
         console.log(body(paint.dim(note)));
     // What a v2 would be worth, in their own values. Said here because this is

package/dist/doctor/architecture.js

@@ -106,15 +106,77 @@ export function describeArchitecture(a) {
  * open one component. And `fact: true`, because it was read off their directories: it is
  * true once, not a habit that needs a third sighting.
  */
-export function architectureRule(a) {
+export function architectureRule(a, 
+/**
+ * O ESCOPO, para a regra dizer um caminho que existe. `a.root` é relativo ao escopo, e uma
+ * regra no CLAUDE.md de um monorepo que diz `src/lib/SignalUI` manda o agente para um caminho
+ * que não resolve da raiz - o mesmo defeito que fez o dono reprovar as opções da pergunta.
+ */
+scope) {
+    const home = componentHome(a, scope);
     return {
-        text: describeArchitecture(a),
+        text: `${describeArchitecture(a)} A new component goes under \`${home}\`.`,
         applies: [],
         kind: "implementation",
         fact: true,
-        evidence: `${a.evidence.join("/")} under ${a.root}, holding ${a.files} component file${a.files === 1 ? "" : "s"}`,
+        evidence: `${a.evidence.join("/")} under ${scope ? `${scope}/${a.root}` : a.root}, holding ${a.files} component file${a.files === 1 ? "" : "s"}`,
     };
 }
+/**
+ * ONDE UM COMPONENTE NOVO VAI, ESCRITO COMO CAMINHO - e o caminho é a resposta.
+ *
+ * O dono leu esta pergunta na tela em 20/08 e a reprovou por uma razão que a versão
+ * anterior não tinha como resolver: *"'manter a escada atômica' não responde onde nasce
+ * o componente"*. O título de cada opção era o NOME DO PADRÃO e a árvore estava enterrada
+ * numa descrição de quatro linhas - então a pergunta pedia uma decisão de organização e
+ * mostrava um glossário.
+ *
+ * A resposta a "onde" é um caminho. Então o caminho é o título, ele vem daqui pronto, e
+ * ele é COMPLETO a partir da raiz do repositório: `src/lib/SignalUI` sem o `packages/ui/`
+ * na frente é ambíguo num monorepo, e é para o CLAUDE.md que essa linha vai.
+ */
+export function componentHome(a, scope) {
+    const base = scope ? `${scope.replace(/\/+$/, "")}/${a.root}` : a.root;
+    const tidy = base.replace(/\/\.$/, "").replace(/^\.\//, "");
+    return a.evidence.length > 0 ? `${tidy}/{${a.evidence.join(", ")}}` : tidy;
+}
+/**
+ * A MESMA FORMA EM UMA FRASE - o que decide, e o número que a torna credível.
+ *
+ * `describeArchitecture` continua existindo e continua longo: ele é a REGRA que vai para
+ * o CLAUDE.md, onde um agente precisa do critério inteiro. Numa lista de opções esse
+ * mesmo texto é o que faz três linhas viraram doze e ninguém ler nenhuma.
+ */
+const LINES = {
+    atomic: (a) => `A rung per what it composes - atom, molecule, organism. ${a.files} files already here.`,
+    feature: (a) => `Beside the feature that uses it; it moves up only when a second one needs it. ${a.files} files.`,
+    layered: (a) => `By layer - ui, hooks, utils - not by feature. ${a.files} files already here.`,
+    flat: (a) => `One folder deep, no ladder. Legible while the system is small. ${a.files} files.`,
+    colocated: (a) => `Beside the route that renders it, shared only when a second page needs it. ${a.files} files.`,
+};
+export function homeLine(a) {
+    return LINES[a.kind](a);
+}
+/**
+ * UMA PASTA NOVA, PROPOSTA - a opção que faltava, e o dono pediu por ela.
+ *
+ * As opções eram todas retratos: manter isto, manter aquilo. Nenhuma deixava alguém dizer
+ * *"daqui em diante vai num lugar novo"*, que é uma resposta legítima e frequente - e sem
+ * ela a pergunta é sobre o passado.
+ *
+ * O caminho é DERIVADO, não inventado: fica dentro do escopo que a pessoa já apontou como
+ * fonte de verdade, e usa `src/` só quando as formas medidas mostram que o escopo tem `src`.
+ * Sem nome de sistema dentro dele de propósito - quem quer isso digita, e digitar um nome
+ * é mais honesto do que a gente adivinhar a grafia dele.
+ */
+export function proposeNewHome(found, scope) {
+    const base = scope ? scope.replace(/\/+$/, "") : "";
+    const hasSrc = found.some((a) => a.root === "src" || a.root.startsWith("src/"));
+    const trunk = `${base ? `${base}/` : ""}${hasSrc ? "src/components" : "components"}`;
+    const fresh = `${trunk}/{atoms, molecules, organisms}`;
+    /** Se a proposta é o que já existe, ela não é uma pasta nova - e oferecê-la seria repetir a opção 1. */
+    return found.some((a) => componentHome(a, scope) === fresh) ? null : fresh;
+}
 /**
  * A ESTRUTURA, ESCRITA - as pastas que a forma tem, na ordem em que ela as usa.
  *

package/dist/index.js

@@ -88,7 +88,11 @@ Options:
   --dir <path>       consumer project root (default: current directory)
   --version <n>      install a specific version (default: latest)
   --ds <slug>        init: bring this DS in right away · generate: target DS (default: installed)
-  --name <name>      preferred component name for generate
+  --name <name>      import: the NAME of the system, which is what its install slug
+                     comes from - and the slug never changes. Also the preferred
+                     component name for generate.
+  --group <name>     import: the GROUP it is born in, by name ("--group SignalUI").
+                     Without it the system lands in your own space.
   --scope <path>     import: the SYSTEM - tokens, components, convention. Repeatable;
                      the first one wins a tie.
   --usage <path>     import: the EVIDENCE - counts, chosen values, laws. Repeatable.
@@ -158,6 +162,14 @@ async function main() {
                 dry: flags.dry === true,
                 census: typeof flags.census === "string" ? flags.census : undefined,
                 name: typeof flags.name === "string" ? flags.name : undefined,
+                /**
+                 * EM QUAL GRUPO ELE NASCE - o nome, como a pessoa o fala.
+                 *
+                 * Sem a flag, no espaço pessoal (o padrão de sempre). Com ela, no grupo que ela nomeou -
+                 * e um nome que a plataforma não reconhece RECUSA o envio em vez de cair no pessoal, que
+                 * é o desvio que ninguém percebe até ir procurar o sistema.
+                 */
+                group: typeof flags.group === "string" ? flags.group : undefined,
                 // Only these two words. Anything else is a typo that would silently
                 // invert a system, so it falls through to being measured and asked.
                 // WHAT to read. `--dir` stays WHERE the project is, in every command.

package/dist/install-marks.js

@@ -202,7 +202,7 @@ export const CHECKER_SINCE = "0.16.250";
  *               (era 53% no melhor caminho; o derivado dava 38%). Um censo medido antes disto não
  *               tem versão nenhuma - e o mapa de blueprints por versão não tem o que consultar.
  */
-export const READER_SINCE = "0.16.240";
+export const READER_SINCE = "0.16.261";
 /**
  * O QUE ESTÁ INSTALADO AQUI FICOU PARA TRÁS - e as DUAS condições que fazem isso ser verdade.
  *

package/dist/naming-queue.js

@@ -0,0 +1,56 @@
+import { anatomyFromSketch } from "./anatomy-from-sketch.js";
+/** O nó que a derivação não soube nomear. `box` é o último recurso dela. */
+const UNNAMED = "box";
+function walk(read, onNode) {
+    for (const node of read) {
+        onNode(node);
+        if (Array.isArray(node.children) && node.children.length > 0)
+            walk(node.children, onNode);
+    }
+}
+/**
+ * A fila, derivada dos mesmos insumos que o envio usa.
+ *
+ * `defines` e `versionOf` entram porque a derivação os usa para distinguir um componente DELES de
+ * uma peça de terceiro, e um nó que vira `component` ou `external` é um nó nomeado: computar a fila
+ * sem eles a inflaria com trabalho que não existe.
+ */
+export function namingQueue(looks, defines, versionOf) {
+    const pending = [];
+    let components = 0;
+    let nodes = 0;
+    let named = 0;
+    let settled = 0;
+    for (const component of Object.keys(looks)) {
+        const sketch = looks[component]?.sketch;
+        if (!Array.isArray(sketch) || sketch.length === 0)
+            continue;
+        const derived = anatomyFromSketch(sketch, defines, versionOf);
+        if (derived.read.length === 0)
+            continue;
+        components += 1;
+        const unnamed = [];
+        walk(derived.read, (node) => {
+            nodes += 1;
+            if (node.name !== UNNAMED) {
+                named += 1;
+                return;
+            }
+            const at = node.at;
+            if (typeof at !== "number")
+                return;
+            const raw = sketch[at];
+            unnamed.push({
+                tag: raw?.tag ?? "div",
+                at,
+                ...(raw?.classes ? { classes: raw.classes } : {}),
+            });
+        });
+        if (unnamed.length === 0) {
+            settled += 1;
+            continue;
+        }
+        pending.push({ component, nodes: unnamed });
+    }
+    return { components, nodes, named, settled, pending };
+}

package/package.json

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