synthesisui 0.16.160 → 0.16.162

package/dist/commands/align.js

@@ -76,8 +76,16 @@ opts = {}) {
     const scope = await measuredScope(root);
     if (!scope.system && scope.usage.length === 0)
         out.push({
-            says: `"${lock.slug}" does not record where it was measured, so a re-measure would read this whole repo instead of the folder the system came from.`,
-            run: "npx synthesisui import --dry --scope <folder>",
+            says: `"${lock.slug}" does not record where it was measured, so a re-measure would read this whole repo instead of the folder the system came from. Sync asks once and remembers the answer.`,
+            /**
+             * O COMANDO QUE ELA JÁ RODA, e nunca um sexto.
+             *
+             * Isto dizia `import --dry --scope <folder>`, que não está no vocabulário de quem usa isto -
+             * `connect`, `login`, `doctor`, `sync`, `upgrade`, e a skill. O `align` é a única coisa que
+             * fala com a pessoa sem ela pedir, e falar ensinando uma palavra que ela nunca viu transfere
+             * para ela um problema que era nosso. O `sync` absorveu o caso - ver `askForScope`.
+             */
+            run: "npx synthesisui sync",
         });
     const events = await readEvents(root).catch(() => []);
     if (events.length > 0)

package/dist/commands/import.js

@@ -79,7 +79,7 @@ const MAX_PER_KIND = {
  * comes from wherever the vocabulary is centralised, and each app is a consumer
  * measured against it.
  */
-async function siblingProjects(root) {
+export async function siblingProjects(root) {
     const apps = [];
     const shared = [];
     for (const group of ["apps", "packages", "libs"]) {
@@ -1205,7 +1205,17 @@ export async function takeCensus(root, opts) {
      * product is broken, reasoning correctly from what they were shown. The gap was never
      * the defect; the silence was (dono, 01/08).
      */
-    const coverage = summarizeCoverage(shapes, componentFiles, Object.keys(looks).length, Object.values(looks).reduce((n, look) => n +
+    /**
+     * O DENOMINADOR CONTA COMPONENTES, e contava ARQUIVOS.
+     *
+     * `looks` é por NOME e `componentFiles` é por arquivo, então um arquivo que exporta dois
+     * componentes produzia "36 of 35 components came out with a look - 103%" (medido na biblioteca do
+     * dono em 06/08). Uma porcentagem que passa de 100 por construção não é um arredondamento: é a
+     * linha que declara a cobertura da esteira inteira se medindo contra outra unidade.
+     *
+     * `componentFiles` segue existindo para as formas de estilo, que SÃO por arquivo.
+     */
+    const coverage = summarizeCoverage(shapes, defined.length || componentFiles, Object.keys(looks).length, Object.values(looks).reduce((n, look) => n +
         Object.keys(look.base).length +
         Object.keys(look.dark ?? {}).length +
         Object.values(look.states).reduce((m, block) => m + Object.keys(block).length, 0) +

package/dist/commands/sync.js

@@ -3,10 +3,10 @@ import { join, resolve } from "node:path";
 import { readToken, resolveRegistry } from "../config.js";
 import { readEvents } from "../doctor/ledger.js";
 import { checkableName, closeRequest, readRequests, verifyAndCloseRequests, } from "../doctor/requests.js";
-import { measuredScope } from "../measured-scope.js";
+import { measuredScope, rememberScope } from "../measured-scope.js";
 import { body, paint, section, snippet } from "../output.js";
 import { repoStateOf } from "../repo-state.js";
-import { resolveReadParts, takeCensus } from "./import.js";
+import { resolveReadParts, siblingProjects, takeCensus } from "./import.js";
 /**
  * What each decision means ON THIS MACHINE - the card decides, the sync
  * enacts. The web never touches the local file; this line is printed right
@@ -206,8 +206,27 @@ export async function remeasure(args) {
      * O servidor continua valendo como segunda fonte: um clone fresco tem o `.lock` e não tem censo.
      */
     const local = await measuredScope(root);
-    const scope = local.system ?? stored.scope ?? null;
-    const usage = local.usage.length > 0 ? local.usage : (stored.usage ?? []);
+    let scope = local.system ?? stored.scope ?? null;
+    let usage = local.usage.length > 0 ? local.usage : (stored.usage ?? []);
+    /**
+     * E QUANDO NINGUÉM SABE, ESTE COMANDO PERGUNTA - uma vez, e grava a resposta.
+     *
+     * Um sistema que perdeu o escopo só tinha uma volta: `import --scope`. Isso é uma SEXTA palavra
+     * no vocabulário de quem usa isto (`connect`, `login`, `doctor`, `sync`, `upgrade`, e a skill), e
+     * uma mensagem que ensina uma palavra nova transfere para a pessoa um problema que era nosso.
+     *
+     * Então o comando que ela já roda absorve o caso: os candidatos saem do próprio repo, a resposta
+     * vai para o `.lock`, e a pergunta não volta.
+     */
+    if (!scope) {
+        const asked = await askForScope(root);
+        if (asked) {
+            scope = asked.scope;
+            if (asked.usage.length > 0)
+                usage = asked.usage;
+            await rememberScope(root, slug, scope, usage);
+        }
+    }
     console.log(section("Measuring your repository again"));
     console.log(body(paint.faint(`${scope ? `scope ${scope}` : "the whole repo"}${local.system && local.system !== stored.scope
         ? " · read from your own census, which is where the last measurement recorded it"
@@ -335,3 +354,44 @@ export async function installedSlug(root) {
     }
     return null;
 }
+/**
+ * DE ONDE ESTE SISTEMA FOI MEDIDO - perguntado uma vez, com os candidatos do próprio repo.
+ *
+ * Os nomes não são digitados: `siblingProjects` já separa o que é biblioteca compartilhada do que é
+ * app, que é exatamente a distinção entre o SISTEMA e quem o CONSOME. Um monorepo responde em uma
+ * tecla; um repo de app único nem chega aqui, porque a raiz é a resposta óbvia e ela não precisa de
+ * pergunta.
+ *
+ * Sem terminal interativo devolve `null` e a medição segue como antes - um CI não pode travar
+ * esperando alguém, e medir a raiz num CI é o comportamento que ele sempre teve.
+ */
+async function askForScope(root) {
+    const { apps, shared } = await siblingProjects(root);
+    if (shared.length === 0)
+        return null;
+    if (!process.stdin.isTTY || !process.stdout.isTTY)
+        return null;
+    console.log(section("Where does this system come from?"));
+    console.log(body("Nothing here records it, so a re-measure would read this whole repo - which produces the average of every app you have, and that is a diagnosis rather than a system."));
+    shared.forEach((name, i) => {
+        console.log(body(`  ${i + 1}. ${name}`));
+    });
+    console.log(body(`  ${shared.length + 1}. the whole repo`));
+    if (apps.length > 0)
+        console.log(body(paint.faint(`${apps.length} app${apps.length === 1 ? "" : "s"} travel as evidence either way: ${apps.slice(0, 3).join(", ")}${apps.length > 3 ? ", …" : ""}`)));
+    const { createInterface } = await import("node:readline/promises");
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = (await rl.question("  which one? [1]: ")).trim();
+        const pick = answer === "" ? 1 : Number(answer);
+        if (!Number.isInteger(pick) || pick < 1 || pick > shared.length)
+            return null;
+        return { scope: shared[pick - 1], usage: apps };
+    }
+    catch {
+        return null;
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/doctor/coverage.js

@@ -92,7 +92,16 @@ export function countShape(source, name, into) {
 }
 export function summarizeCoverage(counts, components, read, declarations) {
     return {
-        components,
+        /**
+         * NUNCA MENOS QUE O QUE FOI LIDO.
+         *
+         * `read` conta LOOKS por nome e o denominador chegava contando ARQUIVOS - um arquivo que exporta
+         * dois componentes produzia `36 of 35 components came out with a look - 103%` na biblioteca do
+         * dono (06/08). O conserto de verdade é o chamador passar a mesma unidade, e ele passa; isto é a
+         * trava, para que a linha que declara a cobertura da esteira inteira não possa afirmar mais do
+         * que existe se outro chamador errar a unidade de novo.
+         */
+        components: Math.max(components, read),
         read,
         declarations,
         counts: [...counts.values()].sort((a, b) => b.files - a.files),

package/dist/measured-scope.js

@@ -1,4 +1,4 @@
-import { readdir, readFile, stat } from "node:fs/promises";
+import { readdir, readFile, stat, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
 const EMPTY = { system: null, usage: [], from: "none" };
 /**
@@ -119,3 +119,31 @@ export function describeScope(m) {
     ];
     return `read from your census: ${parts.join(" · ")}`;
 }
+/**
+ * GRAVA ONDE ESTE SISTEMA FOI MEDIDO, no ponteiro dele.
+ *
+ * Existe para uma resposta ser dada UMA vez. O escopo se perdeu do servidor em 06/08 e o único
+ * caminho de volta era um `import --scope`, que é um comando fora do vocabulário de quem usa isto -
+ * `connect`, `login`, `doctor`, `sync`, `upgrade` e a skill. Uma mensagem que ensina uma sexta
+ * palavra é pior que mensagem nenhuma: ela transfere para a pessoa um problema que era nosso.
+ *
+ * Silencioso quando não há lock: não é erro, é um repo sem sistema instalado.
+ */
+export async function rememberScope(root, slug, scope, usage) {
+    const path = join(root, "_synthesisui", "ds", slug, ".lock");
+    const raw = await readFile(path, "utf8").catch(() => null);
+    if (!raw)
+        return;
+    let lock;
+    try {
+        lock = JSON.parse(raw);
+    }
+    catch {
+        return;
+    }
+    await writeFile(path, `${JSON.stringify({
+        ...lock,
+        ...(scope ? { scope } : {}),
+        ...(usage.length > 0 ? { usage } : {}),
+    }, null, 2)}\n`, "utf8");
+}

package/package.json

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