synthesisui 0.16.261 → 0.16.263

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";
@@ -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";
@@ -1928,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: {
@@ -1964,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) }
             : {}),
@@ -2026,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
@@ -3570,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
@@ -3602,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/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.261",
+  "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": {