synthesisui 0.16.415 → 0.16.417

package/dist/agents-chosen.js

@@ -159,12 +159,11 @@ export async function chooseAgents(input) {
     const pre = remembered ?? (wired.length > 0 ? wired : await detected(input.root));
     if (!input.ask)
         return { agents: pre, from: "evidence", unknown: [] };
-    const typed = await input.ask(pre);
-    /** Enter mantém a pré-marcação - a confirmação é uma tecla, e continua sendo escolha dele. */
-    if (typed.trim() === "")
-        return { agents: pre, from: "asked", unknown: [] };
-    const read = parseAgents(typed);
-    return { agents: read.agents, from: "asked", unknown: read.unknown };
+    const picked = await input.ask(pre);
+    /** Sem terminal para perguntar, a evidência decide - o mesmo caminho de quem não tem TTY. */
+    if (picked === null)
+        return { agents: pre, from: "evidence", unknown: [] };
+    return { agents: picked, from: "asked", unknown: [] };
 }
 /**
  * A ESCOLHA REGISTRADA - e é ela que distingue "ele desmarcou" de "sobrou arquivo no disco".

package/dist/anatomy-from-sketch.js

@@ -212,6 +212,23 @@ function nameOfTag(tag) {
         .replace(/[^a-z0-9]+/g, "-")
         .replace(/^-|-$/g, "");
 }
+/**
+ * A PROP QUE ALIMENTA O ELEMENTO, na mesma grafia dos outros nomes de part.
+ *
+ * `contentFrom` é a expressão verbatim que o JSX escreve, então ela pode ser um identificador
+ * simples (`label`), um acesso (`item.title`) ou uma chamada. Só o que é um nome simples vira
+ * nome de part: um pedaço de expressão viraria uma classe ilegível no CSS compilado, e o nó cai
+ * em `box` como antes. Medido nos dois censos: os 19 do `codelevel-ui` são todos identificadores
+ * simples, e dos 534 do `frontend-hub` a maioria também.
+ */
+function nameOfProp(expression) {
+    const clean = expression.trim();
+    if (!/^[A-Za-z_$][\w$]*$/.test(clean))
+        return undefined;
+    const name = nameOfTag(clean);
+    /** `children` é a palavra do React, não do design dele - ali o nó é um slot, não uma part. */
+    return name && name !== "children" ? name : undefined;
+}
 /**
  * O NOME QUE ELE MESMO DEU AO ELEMENTO - a classe do CSS Module.
  *
@@ -535,6 +552,31 @@ consumedAt) {
         const hasKids = children.length > 0;
         let as;
         let name;
+        /**
+         * O CONTEÚDO QUE VEM DE UMA PROP DELE É CONTEÚDO - A1 da etapa 15 (dono, 11/09).
+         *
+         * O QUE ELE VIA: o `CapabilityCard` dele desenhado como três losangos `✧` soltos, e o `Beam`
+         * como um `✧`. A pergunta dele foi a certa: *"mesmo tendo a receita vindo de um componente
+         * funcionando, não consigo entender o motivo"*.
+         *
+         * A SUPOSIÇÃO QUE ERRAVA estava escrita três linhas abaixo, em voz alta: *"a leaf box with no
+         * content of its own is a drawn SHAPE (...) `icon` is the form for 'a bare shape with no
+         * text'"*. Em React o texto quase nunca é literal no JSX - ele vem de `{label}`, `{children}`,
+         * `{value}`. **"Sem texto literal" não significa "sem conteúdo": significa "o conteúdo vem de
+         * fora".**
+         *
+         * E O COLETOR JÁ SABIA. `contentFrom` é a expressão que aquele elemento escreve, e o contrato
+         * a descreve como *"a evidência de QUAL prop alimenta este elemento"*. A derivação nunca a
+         * consultava. MEDIDO nos dois censos congelados: **19 nós** no `codelevel-ui` e **534** no
+         * `frontend-hub` - e no sistema dele isso era 36 dos 94 nós chegando como `icon`, 20 deles
+         * sem ser glifo nenhum (`label`, `value`, `title`, `eyebrow`, `meta`).
+         *
+         * É EVIDÊNCIA, NUNCA EXECUÇÃO: em outro projeto a prop tem outro nome, e o que atravessa é
+         * que ESTE elemento é onde o conteúdo entra. Por isso a regra lê a PRESENÇA do campo, e a
+         * palavra dele só vira o nome da part.
+         */
+        const writesContent = typeof node.contentFrom === "string" &&
+            node.contentFrom.trim().length > 0;
         if (capitalised) {
             // A primitive's member name is the client's own word for the element.
             name = nameOfTag(tag);
@@ -551,10 +593,25 @@ consumedAt) {
             else if (form)
                 as = form;
             else
-                as = hasKids ? arrangement(classes) : node.text ? "text" : "icon";
+                as = hasKids
+                    ? arrangement(classes)
+                    : node.text || writesContent
+                        ? "text"
+                        : "icon";
         }
         else if (byTag) {
-            name = byTag.name;
+            /**
+             * A PALAVRA DELE VENCE O NOME QUE A TAG SUGERE (A5 da etapa 15).
+             *
+             * `BY_TAG` dá a um `<span>` o nome `text` e a um `<div>` nada - nomes corretos e MUDOS,
+             * que dizem o que a tag é e nada sobre o papel daquele nó no componente dele. Quando o
+             * JSX escreve `<span>{eyebrow}</span>`, `eyebrow` é a palavra que ele usa para aquilo, e
+             * é ela que precisa chegar na tela e no seletor. Perde só para um nome que também é dele
+             * e mais específico: uma classe de module, ou o membro de um componente que ele escreveu.
+             */
+            name =
+                (writesContent ? nameOfProp(String(node.contentFrom)) : undefined) ??
+                    byTag.name;
             if (NEUTRAL.has(lower)) {
                 /**
                  * A leaf box with no content of its own is a drawn SHAPE - a dot, a
@@ -564,7 +621,7 @@ consumedAt) {
                 as =
                     hasKids || node.slot
                         ? arrangement(classes)
-                        : node.text
+                        : node.text || writesContent
                             ? "text"
                             : "icon";
             }
@@ -572,7 +629,7 @@ consumedAt) {
                 as = byTag.as;
         }
         else {
-            as = hasKids ? arrangement(classes) : "icon";
+            as = hasKids ? arrangement(classes) : writesContent ? "text" : "icon";
         }
         /**
          * ANYTHING HOLDING ELEMENTS ARRANGES THEM - the contract gives children to
@@ -598,9 +655,16 @@ consumedAt) {
             /**
              * `box` VIROU A ÚLTIMA OPÇÃO, não a primeira - ver `nameOfModule`. Um nó com
              * classe de module tem nome, e o nome é dele.
+             *
+             * E A PROP QUE ALIMENTA O ELEMENTO VEM ANTES DE `box` (A5 da etapa 15). Os dois nós de
+             * texto do `CapabilityCard` dele chegavam como `box` e `box` - dois irmãos com o mesmo
+             * nome, que é o mesmo que não ter nome. `contentFrom: "label"` é a palavra que o CÓDIGO
+             * DELE escreve, e ela é melhor que qualquer coisa que a gente derivasse da tag.
              */
             name =
-                nameOfModule(node.moduleClass) ?? "box";
+                nameOfModule(node.moduleClass) ??
+                    (writesContent ? nameOfProp(String(node.contentFrom)) : undefined) ??
+                    "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/connect.js

@@ -7,6 +7,7 @@ import { resolveRegistry } from "../config.js";
 import { notAProject, projectRootFrom } from "../is-a-project.js";
 import { fmt, say } from "../lang.js";
 import { body, bodyWrapped, paint, section, snippet } from "../output.js";
+import { canPick, pickMany } from "../pick-many.js";
 import { readShellAnswer, rememberShellNo } from "../shell-answer.js";
 import { existingRc, hasHook, pinnedInHook, rcPathFor, shellFrom, shellSnippet, withHook, } from "../shell-hook.js";
 import { SKILLS } from "../skills.js";
@@ -226,32 +227,29 @@ version) {
 async function askWhichAgents(pre) {
     console.log("");
     console.log(section(say("Which agents")));
-    for (const agent of AGENTS) {
-        const on = pre.includes(agent.id);
-        console.log(body(`${on ? "[x]" : "[ ]"} ${agent.label.padEnd(13)} ${on
-            ? fmt(say("{dir} is here"), { dir: agent.evidence })
-            : fmt(say("no {dir} in this repo"), { dir: agent.evidence })}`));
-    }
+    console.log(body(paint.faint(say("Space marks, arrows move, Enter confirms - nothing is written yet."))));
     console.log("");
-    console.log(body(say("Enter keeps this. To change it, type the ones you want - or `none`:")));
-    console.log(body(paint.faint(`  ${AGENTS.map((a) => a.id).join(" ")}`)));
-    const { createInterface } = await import("node:readline/promises");
-    const rl = createInterface({
-        input: process.stdin,
-        output: process.stdout,
+    if (!canPick())
+        return null;
+    const picked = await pickMany({
+        items: AGENTS.map((agent) => ({
+            id: agent.id,
+            label: agent.label,
+            note: pre.includes(agent.id)
+                ? fmt(say("{dir} is here"), { dir: agent.evidence })
+                : fmt(say("no {dir} in this repo"), { dir: agent.evidence }),
+        })),
+        picked: pre,
     });
-    const typed = await rl.question("  > ").catch(() => "");
-    rl.close();
-    return typed;
+    return picked;
 }
 /**
- * O QUE FICOU ESCOLHIDO, ecoado antes de agir - achado da revisão de DX no fecho.
+ * O QUE FICOU ESCOLHIDO, ecoado antes de agir.
  *
- * A frase da lista já diz que digitar SUBSTITUI o conjunto, e o risco não é de vocabulário: é de
- * hábito. Quem está acostumado com seletor incremental vê `[x] Codex` marcado, digita `claude`
- * querendo acrescentar, e perde o Codex. A consequência aparecia embaixo, misturada com as outras
- * linhas; uma linha só, antes de qualquer escrita, torna o engano visível no lugar onde ele
- * aconteceu.
+ * Nasceu na etapa 12 contra um engano que o seletor de agora não permite mais - lá, digitar
+ * `claude` SUBSTITUÍA a lista, e quem tinha hábito de seletor incremental perdia o outro. Com o
+ * espaço marcando, marcar é aditivo por natureza. A linha fica porque a outra metade dela continua
+ * valendo: ela é a última coisa antes das escritas, e diz o que foi para o disco.
  */
 function echoChoice(agents) {
     console.log("");

package/dist/copy/connect.pt-BR.js

@@ -43,9 +43,9 @@ register("pt-BR", {
      * razão da frase `import my design system`: onde a máquina lê, a precisão vence a gentileza.
      */
     "Which agents": "Quais agentes",
+    "Space marks, arrows move, Enter confirms - nothing is written yet.": "O espaço marca, as setas movem, o Enter confirma - nada foi escrito ainda.",
     "{dir} is here": "{dir} está aqui",
     "no {dir} in this repo": "nenhum {dir} neste repo",
-    "Enter keeps this. To change it, type the ones you want - or `none`:": "Enter mantém isto. Para mudar, digite os que você quer - ou `none`:",
     "· {label} not chosen - these stay in the repo: {files}": "· {label} não escolhido - estes ficam no repo: {files}",
     "· {label} not chosen - nothing of it was written": "· {label} não escolhido - nada dele foi escrito",
     "· Cursor is no longer wired by this CLI - what we wrote is still here: {files}": "· o Cursor não é mais fiado por este CLI - o que a gente escreveu continua aqui: {files}",

package/dist/install-marks.js

@@ -214,7 +214,19 @@
  * O que o cliente ganha ao rodar `upgrade`: nada de uma ferramenta que ele não usa é reescrito no
  * repositório dele.
  */
-export const MATERIALISER_SINCE = "0.16.415";
+/**
+ * 0.16.415 -> 0.16.416 em 10/09: a lista de agentes passa a ser MARCADA com o espaço, e não
+ * digitada. Ele testou a versão anterior no próprio repositório e disse: *"eu não consigo
+ * selecionar, eu queria clicar ou selecionar com o espaço para checar"* - a tela desenhava `[x]` e
+ * `[ ]`, a forma universal de caixa de seleção, e exigia digitar o nome do agente.
+ *
+ * A marca sobe porque a ESCOLHA decide o conjunto de arquivos que cai na pasta dele, e um
+ * `connect` pinado numa versão anterior pede aquela escolha de um jeito que ele já tentou e que
+ * não funcionou.
+ *
+ * O que o cliente ganha ao rodar `upgrade`: a lista responde ao espaço, como a caixa promete.
+ */
+export const MATERIALISER_SINCE = "0.16.416";
 /**
  * A ÚLTIMA VERSÃO EM QUE O QUE O HOOK RODA MUDOU.
  *
@@ -781,7 +793,7 @@ export const CHECKER_SINCE = "0.16.413";
  * deveriam estar lá. Quem tem censo gravado precisa de um `sync` para a fila de trabalho dele ser a
  * real; ver o livro-razão de `corpus.spec.ts`.
  */
-export const READER_SINCE = "0.16.408";
+export const READER_SINCE = "0.16.417";
 /**
  * O QUE ESTÁ INSTALADO AQUI FICOU PARA TRÁS - e as DUAS condições que fazem isso ser verdade.
  *

package/dist/pick-many.js

@@ -0,0 +1,108 @@
+/**
+ * ELE MARCA COM O ESPAÇO - a lista de escolha MÚLTIPLA do terminal.
+ *
+ * O DEFEITO QUE ISTO CONSERTA, e ele foi achado por ELE testando a entrega anterior no próprio
+ * repositório (10/09): *"eu não consigo selecionar, eu queria clicar ou selecionar com o espaço
+ * para checar"*. A lista desenhava `[x]` e `[ ]` - a forma universal de caixa de seleção - e
+ * exigia digitar o nome do item. A tela prometia uma interação que não existia, e a promessa da
+ * tela é a única que a pessoa lê.
+ *
+ * O IRMÃO JÁ EXISTIA: `commands/import.ts` tem um seletor de escolha ÚNICA desde 31/07 - setas,
+ * Enter, Ctrl-C tratado, redesenho subindo N linhas. Este é o mesmo mecanismo com a diferença que
+ * importa: o espaço marca e desmarca, e a resposta é uma lista. Os dois ficam, porque a pergunta
+ * "qual" e a pergunta "quais" são diferentes na tela; o que não pode existir é uma TERCEIRA
+ * leitura de tecla neste CLI.
+ *
+ * ─────────────────────────────────────────────────────────────────────────
+ * AS TRÊS COISAS QUE PODEM DAR ERRADO FORA DO NOSSO PROGRAMA, e é por elas que este módulo é
+ * pequeno e fechado:
+ *
+ *     o raw mode fica ligado     o shell dele para de ecoar o que ele digita, muito depois de a
+ *                               gente ter terminado. Restaurado em TODA saída, inclusive a de erro
+ *     Ctrl-C vira escolha       sair não é escolher. O `onQuit` encerra sem resolver a promessa
+ *     não há terminal           não se tenta ler tecla nenhuma: quem chama decide o que fazer,
+ *                               e no `connect` isso já tem resposta desde a etapa 12
+ *
+ * `stdin` e `stdout` são ARGUMENTOS porque um seletor que fala com `process` direto não tem como
+ * ser provado sem um terminal - e o que precisa de prova aqui é a leitura de tecla, não o
+ * desenho.
+ */
+/** O terminal tem teclado? Sem isto, não se tenta ler tecla nenhuma. */
+export const canPick = (stdin = process.stdin, stdout = process.stdout) => Boolean(stdin.isTTY) &&
+    Boolean(stdout.isTTY) &&
+    typeof stdin.setRawMode === "function";
+const UP = "";
+const DOWN = "";
+const ENTER_KEYS = ["\r", "\n"];
+const CTRL_C = "";
+export function pickMany(input) {
+    const stdin = (input.stdin ?? process.stdin);
+    const stdout = input.stdout ?? process.stdout;
+    const items = input.items;
+    const marked = new Set(input.picked);
+    let at = 0;
+    let first = true;
+    const render = () => {
+        if (!first)
+            stdout.write(`[${items.length}A`);
+        first = false;
+        for (const [i, item] of items.entries()) {
+            const box = marked.has(item.id) ? "[x]" : "[ ]";
+            const cursor = i === at ? ">" : " ";
+            const note = item.note ? `  ${item.note}` : "";
+            stdout.write(`  ${cursor} ${box} ${item.label.padEnd(13)}${note}\n`);
+        }
+    };
+    render();
+    return new Promise((resolve) => {
+        /**
+         * UMA SAÍDA SÓ, e é ela que garante a promessa do raw mode. Toda tecla que termina a
+         * pergunta passa por aqui - inclusive o Ctrl-C.
+         */
+        const leave = () => {
+            stdin.off("data", onData);
+            if (stdin.isTTY)
+                stdin.setRawMode?.(false);
+            stdin.pause();
+        };
+        const onData = (buf) => {
+            const key = buf.toString();
+            if (key === CTRL_C) {
+                leave();
+                stdout.write("\n");
+                (input.onQuit ?? (() => process.exit(130)))();
+                return;
+            }
+            if (key === UP || key === "k") {
+                at = (at + items.length - 1) % items.length;
+                render();
+                return;
+            }
+            if (key === DOWN || key === "j" || key === "\t") {
+                at = (at + 1) % items.length;
+                render();
+                return;
+            }
+            if (key === " ") {
+                const id = items[at]?.id;
+                if (id !== undefined) {
+                    if (marked.has(id))
+                        marked.delete(id);
+                    else
+                        marked.add(id);
+                    render();
+                }
+                return;
+            }
+            if (ENTER_KEYS.includes(key)) {
+                leave();
+                /** Na ORDEM da lista, e não na ordem em que ele marcou - a tela é que ele leu. */
+                resolve(items.filter((i) => marked.has(i.id)).map((i) => i.id));
+            }
+        };
+        if (stdin.isTTY)
+            stdin.setRawMode?.(true);
+        stdin.resume();
+        stdin.on("data", onData);
+    });
+}

package/package.json

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